update: add downtime integration test for ssl tunnel mode

Author: pvlugter

src/test/java/io/r2dbc/postgresql/client/DowntimeIntegrationTests.java

@@ -18,41 +18,65 @@
 
 import io.r2dbc.postgresql.PostgresqlConnectionConfiguration;
 import io.r2dbc.postgresql.PostgresqlConnectionFactory;
+import io.r2dbc.postgresql.api.PostgresqlException;
 import org.junit.jupiter.api.Test;
 import reactor.netty.DisposableChannel;
 import reactor.netty.DisposableServer;
 import reactor.netty.tcp.TcpServer;
 import reactor.test.StepVerifier;
 
+import java.nio.channels.ClosedChannelException;
+import java.util.function.Consumer;
+
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class DowntimeIntegrationTests {
 
+    // Simulate server downtime, where connections are accepted and then closed immediately
+    static DisposableServer newServer() {
+        return TcpServer.create()
+            .doOnConnection(DisposableChannel::dispose)
+            .bindNow();
+    }
+
+    static PostgresqlConnectionFactory newConnectionFactory(DisposableServer server, SSLMode sslMode) {
+        return new PostgresqlConnectionFactory(
+            PostgresqlConnectionConfiguration.builder()
+                .host(server.host())
+                .port(server.port())
+                .username("test")
+                .sslMode(sslMode)
+                .build());
+    }
+
+    static void verifyError(SSLMode sslMode, Consumer<Throwable> assertions) {
+        DisposableServer server = newServer();
+        PostgresqlConnectionFactory connectionFactory = newConnectionFactory(server, sslMode);
+        connectionFactory.create().as(StepVerifier::create).verifyErrorSatisfies(assertions);
+        server.disposeNow();
+    }
+
     @Test
     void failSslHandshakeIfInboundClosed() {
-        // Simulate server downtime, where connections are accepted and then closed immediately
-        DisposableServer server =
-            TcpServer.create()
-                .doOnConnection(DisposableChannel::dispose)
-                .bindNow();
-
-        PostgresqlConnectionFactory connectionFactory =
-            new PostgresqlConnectionFactory(
-                PostgresqlConnectionConfiguration.builder()
-                    .host(server.host())
-                    .port(server.port())
-                    .username("test")
-                    .sslMode(SSLMode.REQUIRE)
-                    .build());
-
-        connectionFactory.create()
-            .as(StepVerifier::create)
-            .verifyErrorSatisfies(error ->
-                assertThat(error)
-                    .isInstanceOf(AbstractPostgresSSLHandlerAdapter.PostgresqlSslException.class)
-                    .hasMessage("Connection closed during SSL negotiation"));
+        verifyError(SSLMode.REQUIRE, error ->
+            assertThat(error)
+                .isInstanceOf(AbstractPostgresSSLHandlerAdapter.PostgresqlSslException.class)
+                .hasMessage("Connection closed during SSL negotiation"));
+    }
 
-        server.disposeNow();
+    @Test
+    void failSslTunnelIfInboundClosed() {
+        verifyError(SSLMode.TUNNEL, error -> {
+            assertThat(error)
+                .isInstanceOf(PostgresqlException.class)
+                .cause()
+                .isInstanceOf(ClosedChannelException.class);
+
+            assertThat(error.getCause().getSuppressed().length).isOne();
+
+            assertThat(error.getCause().getSuppressed()[0])
+                .hasMessage("Connection closed while SSL/TLS handshake was in progress");
+        });
     }
 
 }