Added unit tests for connectivity verification

Author: lutovich

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

@@ -119,7 +119,6 @@ public CompletionStage<Void> closeAsync()
         return completedFuture( null );
     }
 
-    // todo: test this method and it's usage in DriverFactory
     public CompletionStage<Void> verifyConnectivity()
     {
         return sessionFactory.verifyConnectivity();

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

@@ -30,6 +30,7 @@
 import java.util.Arrays;
 import java.util.List;
 
+import org.neo4j.driver.internal.async.BootstrapFactory;
 import org.neo4j.driver.internal.cluster.RoutingSettings;
 import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer;
 import org.neo4j.driver.internal.retry.RetryLogic;
@@ -38,21 +39,24 @@
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.spi.ConnectionPool;
 import org.neo4j.driver.internal.spi.ConnectionProvider;
-import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.v1.AuthToken;
 import org.neo4j.driver.v1.AuthTokens;
 import org.neo4j.driver.v1.Config;
 import org.neo4j.driver.v1.Driver;
+import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;
 
 import static java.util.concurrent.CompletableFuture.completedFuture;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.neo4j.driver.internal.util.Futures.failedFuture;
 import static org.neo4j.driver.v1.AccessMode.READ;
 import static org.neo4j.driver.v1.Config.defaultConfig;
 
@@ -94,7 +98,7 @@ public void connectionPoolCloseExceptionIsSuppressedWhenDriverCreationFails() th
     {
         ConnectionPool connectionPool = connectionPoolMock();
         RuntimeException poolCloseError = new RuntimeException( "Pool close error" );
-        when( connectionPool.close() ).thenReturn( Futures.failedFuture( poolCloseError ) );
+        when( connectionPool.close() ).thenReturn( failedFuture( poolCloseError ) );
 
         DriverFactory factory = new ThrowingDriverFactory( connectionPool );
 
@@ -135,6 +139,41 @@ public void usesLeakLoggingSessionFactoryWhenConfigured()
         assertThat( capturedFactory.newInstance( READ, null ), instanceOf( LeakLoggingNetworkSession.class ) );
     }
 
+    @Test
+    public void shouldVerifyConnectivity()
+    {
+        SessionFactory sessionFactory = mock( SessionFactory.class );
+        when( sessionFactory.verifyConnectivity() ).thenReturn( completedFuture( null ) );
+        when( sessionFactory.close() ).thenReturn( completedFuture( null ) );
+        DriverFactoryWithSessions driverFactory = new DriverFactoryWithSessions( sessionFactory );
+
+        try ( Driver driver = createDriver( driverFactory ) )
+        {
+            assertNotNull( driver );
+            verify( sessionFactory ).verifyConnectivity();
+        }
+    }
+
+    @Test
+    public void shouldThrowWhenUnableToVerifyConnectivity()
+    {
+        SessionFactory sessionFactory = mock( SessionFactory.class );
+        ServiceUnavailableException error = new ServiceUnavailableException( "Hello" );
+        when( sessionFactory.verifyConnectivity() ).thenReturn( failedFuture( error ) );
+        when( sessionFactory.close() ).thenReturn( completedFuture( null ) );
+        DriverFactoryWithSessions driverFactory = new DriverFactoryWithSessions( sessionFactory );
+
+        try
+        {
+            createDriver( driverFactory );
+            fail( "Exception expected" );
+        }
+        catch ( ServiceUnavailableException e )
+        {
+            assertEquals( "Hello", e.getMessage() );
+        }
+    }
+
     private Driver createDriver( DriverFactory driverFactory )
     {
         return createDriver( driverFactory, defaultConfig() );
@@ -222,4 +261,34 @@ protected ConnectionPool createConnectionPool( AuthToken authToken, SecurityPlan
             return connectionPoolMock();
         }
     }
+
+    private static class DriverFactoryWithSessions extends DriverFactory
+    {
+        final SessionFactory sessionFactory;
+
+        DriverFactoryWithSessions( SessionFactory sessionFactory )
+        {
+            this.sessionFactory = sessionFactory;
+        }
+
+        @Override
+        protected Bootstrap createBootstrap()
+        {
+            return BootstrapFactory.newBootstrap( 1 );
+        }
+
+        @Override
+        protected ConnectionPool createConnectionPool( AuthToken authToken, SecurityPlan securityPlan,
+                Bootstrap bootstrap, Config config )
+        {
+            return connectionPoolMock();
+        }
+
+        @Override
+        protected SessionFactory createSessionFactory( ConnectionProvider connectionProvider, RetryLogic retryLogic,
+                Config config )
+        {
+            return sessionFactory;
+        }
+    }
 }

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

@@ -20,9 +20,12 @@
 
 import org.junit.Test;
 
+import java.util.concurrent.CompletableFuture;
+
 import org.neo4j.driver.internal.security.SecurityPlan;
 
 import static java.util.concurrent.CompletableFuture.completedFuture;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -55,6 +58,18 @@ public void shouldNotCloseSessionFactoryMultipleTimes()
         verify( sessionFactory ).close();
     }
 
+    @Test
+    public void shouldVerifyConnectivity()
+    {
+        SessionFactory sessionFactory = sessionFactoryMock();
+        CompletableFuture<Void> connectivityStage = completedFuture( null );
+        when( sessionFactory.verifyConnectivity() ).thenReturn( connectivityStage );
+
+        InternalDriver driver = newDriver( sessionFactory );
+
+        assertEquals( connectivityStage, driver.verifyConnectivity() );
+    }
+
     private static InternalDriver newDriver( SessionFactory sessionFactory )
     {
         return new InternalDriver( SecurityPlan.insecure(), sessionFactory, DEV_NULL_LOGGING );