Expose transaction open status in AsyncTransaction and RxTransaction

This update adds the following methods:
- `AsyncTransaction.isOpenAsync`
- `RxTransaction.isOpen`

They can be used to verify if transaction is open.

Author: injectives

driver/clirr-ignored-differences.xml

@@ -122,4 +122,16 @@
         <method>org.reactivestreams.Publisher isOpen()</method>
     </difference>
 
+    <difference>
+        <className>org/neo4j/driver/async/AsyncTransaction</className>
+        <differenceType>7012</differenceType>
+        <method>java.util.concurrent.CompletionStage isOpenAsync()</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/reactive/RxTransaction</className>
+        <differenceType>7012</differenceType>
+        <method>org.reactivestreams.Publisher isOpen()</method>
+    </difference>
+
 </differences>

driver/src/main/java/org/neo4j/driver/async/AsyncTransaction.java

@@ -98,4 +98,11 @@ public interface AsyncTransaction extends AsyncQueryRunner
      * @return new {@link CompletionStage} that gets completed with {@code null} when close is successful, otherwise it gets completed exceptionally.
      */
     CompletionStage<Void> closeAsync();
+
+    /**
+     * Determine if transaction is open.
+     *
+     * @return a {@link CompletionStage} completed with {@code true} if transaction is open and {@code false} otherwise.
+     */
+    CompletionStage<Boolean> isOpenAsync();
 }

driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java

@@ -18,6 +18,7 @@
  */
 package org.neo4j.driver.internal.async;
 
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.Query;
@@ -50,6 +51,12 @@ public CompletionStage<Void> closeAsync()
         return tx.closeAsync();
     }
 
+    @Override
+    public CompletionStage<Boolean> isOpenAsync()
+    {
+        return CompletableFuture.completedFuture( isOpen() );
+    }
+
     @Override
     public CompletionStage<ResultCursor> runAsync( Query query )
     {

driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java

@@ -19,6 +19,7 @@
 package org.neo4j.driver.internal.reactive;
 
 import org.reactivestreams.Publisher;
+import reactor.core.publisher.Mono;
 
 import java.util.concurrent.CompletableFuture;
 
@@ -81,6 +82,12 @@ public Publisher<Void> close()
         return close( false );
     }
 
+    @Override
+    public Publisher<Boolean> isOpen()
+    {
+        return Mono.just( tx.isOpen() );
+    }
+
     Publisher<Void> close( boolean commit )
     {
         return createEmptyPublisher( () -> tx.closeAsync( commit ) );

driver/src/main/java/org/neo4j/driver/reactive/RxTransaction.java

@@ -56,4 +56,11 @@ public interface RxTransaction extends RxQueryRunner
      * @return new {@link Publisher} that gets completed when close is successful, otherwise an error is signalled.
      */
     Publisher<Void> close();
+
+    /**
+     * Determine if transaction is open.
+     *
+     * @return a publisher emitting {@code true} if transaction is open and {@code false} otherwise.
+     */
+    Publisher<Boolean> isOpen();
 }

driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java

@@ -24,6 +24,7 @@
 import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
@@ -42,8 +43,11 @@
 import static java.util.Collections.singletonMap;
 import static java.util.concurrent.CompletableFuture.completedFuture;
 import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.then;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -139,4 +143,21 @@ void shouldReleaseConnectionWhenFailedToRollback()
         verify( connection ).release();
         assertFalse( tx.isOpen() );
     }
+
+    @Test
+    void shouldDelegateIsOpenAsync() throws ExecutionException, InterruptedException
+    {
+        // GIVEN
+        UnmanagedTransaction utx = mock( UnmanagedTransaction.class );
+        boolean expected = false;
+        given( utx.isOpen() ).willReturn( expected );
+        tx = new InternalAsyncTransaction( utx );
+
+        // WHEN
+        boolean actual = tx.isOpenAsync().toCompletableFuture().get();
+
+        // THEN
+        assertEquals( expected, actual );
+        then( utx ).should().isOpen();
+    }
 }

driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java

@@ -47,6 +47,8 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.then;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -163,4 +165,18 @@ void shouldDelegateClose()
 
         verify( tx ).closeAsync( false );
     }
+
+    @Test
+    void shouldDelegateIsOpenAsync()
+    {
+        // GIVEN
+        UnmanagedTransaction utx = mock( UnmanagedTransaction.class );
+        boolean expected = false;
+        given( utx.isOpen() ).willReturn( expected );
+        RxTransaction tx = new InternalRxTransaction( utx );
+
+        // WHEN & THEN
+        StepVerifier.create( tx.isOpen() ).expectNext( expected ).expectComplete().verify();
+        then( utx ).should().isOpen();
+    }
 }