Add PostgreSQL unix domain socket test based on test containers (previously was ru.yandex.qatools.embed/postgresql-embedded)

Author: vietj

vertx-pg-client/pom.xml

@@ -58,14 +58,6 @@
     </dependency>
 
     <!-- Testing purposes -->
-<!--
-    <dependency>
-      <groupId>ru.yandex.qatools.embed</groupId>
-      <artifactId>postgresql-embedded</artifactId>
-      <version>2.10</version>
-      <scope>test</scope>
-    </dependency>
--->
     <dependency>
       <groupId>net.java.dev.jna</groupId>
       <artifactId>jna</artifactId>

vertx-pg-client/src/test/java/io/vertx/tests/pgclient/UnixDomainSocketTest.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2018 Julien Viet
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package io.vertx.tests.pgclient;
+
+import io.vertx.pgclient.PgBuilder;
+import io.vertx.pgclient.PgConnectOptions;
+import io.vertx.pgclient.SslMode;
+import io.vertx.core.Vertx;
+import io.vertx.core.VertxOptions;
+import io.vertx.ext.unit.TestContext;
+import io.vertx.ext.unit.junit.VertxUnitRunner;
+import io.vertx.sqlclient.Pool;
+import io.vertx.sqlclient.SqlClient;
+import io.vertx.sqlclient.SqlConnectOptions;
+import io.vertx.sqlclient.impl.ConnectionFactoryBase;
+import io.vertx.tests.pgclient.junit.ContainerPgRule;
+import org.junit.*;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assume.assumeTrue;
+
+@RunWith(VertxUnitRunner.class)
+public class UnixDomainSocketTest {
+
+  @ClassRule
+  public static ContainerPgRule rule = new ContainerPgRule();
+  private Pool client;
+  private PgConnectOptions options;
+  private Vertx vertx;
+
+  @Before
+  public void before() {
+    Assume.assumeNotNull(rule.domainSocketPath());
+    vertx = Vertx.vertx(new VertxOptions().setPreferNativeTransport(true));
+    options = rule.options().setHost(rule.domainSocketPath()).setPort(5432);
+  }
+
+  @After
+  public void after(TestContext ctx) {
+    if (vertx != null) {
+      vertx.close().onComplete(ctx.asyncAssertSuccess());
+    }
+    if (client != null) {
+      client.close().onComplete(ctx.asyncAssertSuccess());
+    }
+  }
+
+  @Test
+  public void uriTest(TestContext context) {
+    String uri = "postgresql://postgres:postgres@/postgres?host=" + options.getHost() + "&port=" + options.getPort();
+    client = PgBuilder.pool().connectingTo(uri).using(vertx).build();
+    client
+      .getConnection()
+      .onComplete(context.asyncAssertSuccess(SqlClient::close));
+  }
+
+  @Test
+  public void simpleConnect(TestContext context) {
+    client = PgBuilder.pool().connectingTo(new PgConnectOptions(options)).using(vertx).build();
+    client
+      .getConnection()
+      .onComplete(context.asyncAssertSuccess(pgConnection -> pgConnection.close().onComplete(context.asyncAssertSuccess())));
+  }
+
+  @Test
+  public void connectWithVertxInstance(TestContext context) {
+    client = PgBuilder.pool().connectingTo(new PgConnectOptions(options)).using(vertx).build();
+    client
+      .getConnection()
+      .onComplete(context.asyncAssertSuccess(pgConnection -> {
+        pgConnection.close();
+      }));
+  }
+
+  @Ignore
+  @Test
+  public void testIgnoreSslMode(TestContext context) {
+    client = PgBuilder.pool().connectingTo(new PgConnectOptions(options).setSslMode(SslMode.REQUIRE)).using(vertx).build();
+    client
+      .getConnection()
+      .onComplete(context.asyncAssertSuccess(pgConnection -> {
+      assertFalse(pgConnection.isSSL());
+      pgConnection.close();
+    }));
+  }
+
+  @Test
+  public void testNativeTransportMustBeEnabled(TestContext ctx) {
+    Pool pool = PgBuilder.pool().connectingTo(SqlConnectOptions.fromUri("postgresql:///dbname?host=/var/lib/postgresql")).build();
+    pool.getConnection().onComplete(ctx.asyncAssertFailure(err -> {
+      assertEquals(ConnectionFactoryBase.NATIVE_TRANSPORT_REQUIRED, err.getMessage());
+    }));
+  }
+}

vertx-pg-client/src/test/java/io/vertx/tests/pgclient/junit/ContainerPgRule.java

@@ -24,10 +24,15 @@
 import org.testcontainers.containers.InternetProtocol;
 import org.testcontainers.containers.wait.strategy.LogMessageWaitStrategy;
 
+import java.io.File;
+import java.nio.file.Files;
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.List;
 
 import static io.vertx.pgclient.PgConnectOptions.DEFAULT_PORT;
+import static org.junit.Assert.assertTrue;
 
 /**
  * Postgresql test database based on https://www.testcontainers.org
@@ -48,6 +53,7 @@ public class ContainerPgRule extends ExternalResource {
   private boolean ssl;
   private boolean forceSsl;
   private String user = "postgres";
+  private File domainSocketMount;
 
   public ContainerPgRule ssl(boolean ssl) {
     this.ssl = ssl;
@@ -76,6 +82,18 @@ public ContainerPgRule user(String user) {
   }
 
   private void initServer(String version) throws Exception {
+
+    // Domain socket on Linux
+    String osName = System.getProperty("os.name");
+    if (osName != null && (osName.startsWith("Linux") || osName.startsWith("LINUX"))) {
+      // Create temp file, length must be < 107 chars (Linux limitation)
+      domainSocketMount = Files.createTempDirectory("postgresql_var_run").toFile();
+      domainSocketMount.deleteOnExit();
+      domainSocketMount.setReadable(true, false);
+      domainSocketMount.setWritable(true, false);
+      domainSocketMount.setExecutable(true, false);
+    }
+
     server = new ServerContainer<>("postgres:" + version)
       .withEnv("POSTGRES_DB", "postgres")
       .withEnv("POSTGRES_USER", user)
@@ -86,6 +104,11 @@ private void initServer(String version) throws Exception {
         .withStartupTimeout(Duration.of(60, ChronoUnit.SECONDS)))
       .withCommand("postgres", "-c", "fsync=off")
       .withClasspathResourceMapping("create-postgres.sql", "/docker-entrypoint-initdb.d/create-postgres.sql", BindMode.READ_ONLY);
+
+    if (domainSocketMount != null) {
+      server = server.withFileSystemBind(domainSocketMount.getAbsolutePath(), "/var/run/postgresql");
+    }
+
     if (ssl) {
       server
         .withClasspathResourceMapping("tls/server.crt", "/server.crt", BindMode.READ_ONLY)
@@ -104,6 +127,10 @@ private void initServer(String version) throws Exception {
     }
   }
 
+  public String domainSocketPath() {
+    return domainSocketMount != null ? domainSocketMount.getAbsolutePath() : null;
+  }
+
   public static boolean isTestingWithExternalDatabase() {
     return isSystemPropertyValid(connectionUri) || isSystemPropertyValid(tlsConnectionUri) || isSystemPropertyValid(tlsForceConnectionUri);
   }
@@ -124,7 +151,6 @@ public synchronized PgConnectOptions startServer(String databaseVersion) throws
         .setPassword("postgres");
   }
 
-
   private static String getPostgresVersion() {
     String specifiedVersion = System.getProperty("embedded.postgres.version");
     String version;
@@ -138,7 +164,7 @@ private static String getPostgresVersion() {
     return version;
   }
 
-  public synchronized void stopServer() throws Exception {
+  public synchronized void stopServer() {
     if (server != null) {
       try {
         server.stop();