Fully implement Driver.getPropertyInfo method

Closes #66

Author: maximevw

Diff for: CHANGELOG.md

@@ -12,14 +12,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - Add support for the special CQL command `CONSISTENCY [level]` in `CassandraStatement` (inspired by PR
   [#56](https://github.com/ing-bank/cassandra-jdbc-wrapper/pull/56)). 
 - Add a method `setComplianceMode(String)` in `CassandraDataSource` to specify a specific compliance mode when getting
-  the connection from a `DataSource` (see issue [#68](https://github.com/ing-bank/cassandra-jdbc-wrapper/issues/68)).
+  the connection from a `DataSource` (see issue [#68](https://github.com/ing-bank/cassandra-jdbc-wrapper/issues/68), 
+  PR [#69](https://github.com/ing-bank/cassandra-jdbc-wrapper/pull/69)).
 ### Changed
 - Update Java Driver for Apache Cassandra® to version 4.18.1.
 - Update Jackson dependencies to version 2.17.1.
 - Modify the scale value returned for the type `TIMESTAMP` (see PR
   [#58](https://github.com/ing-bank/cassandra-jdbc-wrapper/pull/58)).
 - Refactor handling of user-defined types and tuples in `CassandraResultSet.getObject(int | String)` (see PR
   [#60](https://github.com/ing-bank/cassandra-jdbc-wrapper/pull/60)).
+- Fully implement `CassandraDriver.getPropertyInfo(String, Properties)` (see issue
+  [#66](https://github.com/ing-bank/cassandra-jdbc-wrapper/issues/66)).
 ### Fixed
 - Fix implementation of the methods `CassandraStatement.execute(String)` and `CassandraPreparedStatement.execute()` to
   return `true` even when the result set is empty (see 

Diff for: pom.xml

@@ -112,6 +112,7 @@
         <java.version>1.8</java.version>
 
         <!-- Versions for dependencies -->
+        <approvaltests.version>24.3.0</approvaltests.version>
         <checkstyle.version>9.3</checkstyle.version>
         <caffeine.version>2.9.3</caffeine.version>
         <cassandra-driver-krb5.version>3.0.0</cassandra-driver-krb5.version>
@@ -301,6 +302,13 @@
             <version>${slf4j.version}</version>
             <scope>test</scope>
         </dependency>
+        <!-- Approval tests -->
+        <dependency>
+            <groupId>com.approvaltests</groupId>
+            <artifactId>approvaltests</artifactId>
+            <version>${approvaltests.version}</version>
+            <scope>test</scope>
+        </dependency>
         <!-- Lombok (used only for some tests) -->
         <dependency>
             <groupId>org.projectlombok</groupId>

Diff for: src/main/java/com/ing/data/cassandra/jdbc/CassandraDriver.java

@@ -18,28 +18,56 @@
 import com.github.benmanes.caffeine.cache.CacheLoader;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.LoadingCache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import javax.annotation.Nonnull;
 import java.sql.Connection;
 import java.sql.Driver;
 import java.sql.DriverManager;
 import java.sql.DriverPropertyInfo;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.sql.SQLNonTransientConnectionException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 
+import static com.ing.data.cassandra.jdbc.utils.DriverUtil.buildPropertyInfo;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.getDriverProperty;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.safeParseVersion;
 import static com.ing.data.cassandra.jdbc.utils.ErrorConstants.CONNECTION_CREATION_FAILED;
 import static com.ing.data.cassandra.jdbc.utils.ErrorConstants.NOT_SUPPORTED;
+import static com.ing.data.cassandra.jdbc.utils.ErrorConstants.PROPERTIES_PARSING_FROM_URL_FAILED;
 import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.PROTOCOL;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_ACTIVE_PROFILE;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_CLOUD_SECURE_CONNECT_BUNDLE;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_COMPLIANCE_MODE;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_CONFIG_FILE;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_CONNECT_TIMEOUT;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_CONSISTENCY_LEVEL;
 import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_CONTACT_POINTS;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_DEBUG;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_ENABLE_SSL;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_FETCH_SIZE;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_KEEP_ALIVE;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_LOAD_BALANCING_POLICY;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_LOCAL_DATACENTER;
 import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_PASSWORD;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_RECONNECT_POLICY;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_REQUEST_TIMEOUT;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_RETRY_POLICY;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_SSL_ENGINE_FACTORY;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_SSL_HOSTNAME_VERIFICATION;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_TCP_NO_DELAY;
 import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_USER;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_USE_KERBEROS;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.parseURL;
 
 /**
  * The Cassandra driver implementation.
@@ -56,11 +84,13 @@ public class CassandraDriver implements Driver {
         }
     }
 
+    private static final Logger LOG = LoggerFactory.getLogger(CassandraDriver.class);
+
     // Caching sessions so that multiple CassandraConnections created with the same parameters use the same Session.
     private final LoadingCache<Map<String, String>, SessionHolder> sessionsCache = Caffeine.newBuilder()
         .build(new CacheLoader<Map<String, String>, SessionHolder>() {
             @Override
-            public SessionHolder load(final Map<String, String> params) throws Exception {
+            public SessionHolder load(@Nonnull final Map<String, String> params) throws Exception {
                 return new SessionHolder(params, sessionsCache);
             }
         });
@@ -121,19 +151,30 @@ public int getMinorVersion() {
 
     @Override
     public DriverPropertyInfo[] getPropertyInfo(final String url, final Properties props) {
-        Properties properties = props;
-        if (props == null) {
-            properties = new Properties();
+        Properties properties;
+        try {
+            properties = parseURL(url);
+            for (Map.Entry<Object, Object> propEntry : props.entrySet()) {
+                properties.putIfAbsent(propEntry.getKey(), propEntry.getValue());
+            }
+        } catch (final SQLException e) {
+            LOG.warn(PROPERTIES_PARSING_FROM_URL_FAILED, e);
+            properties = new Properties(props);
         }
-        final DriverPropertyInfo[] info = new DriverPropertyInfo[2];
 
-        info[0] = new DriverPropertyInfo(TAG_USER, properties.getProperty(TAG_USER));
-        info[0].description = "The 'user' property";
+        // Define the list of availableProperties.
+        final List<String> availableProperties = Arrays.asList(TAG_USER, TAG_PASSWORD, TAG_LOCAL_DATACENTER, TAG_DEBUG,
+            TAG_CONSISTENCY_LEVEL, TAG_ACTIVE_PROFILE, TAG_FETCH_SIZE, TAG_LOAD_BALANCING_POLICY, TAG_RETRY_POLICY,
+            TAG_RECONNECT_POLICY, TAG_ENABLE_SSL, TAG_SSL_ENGINE_FACTORY, TAG_SSL_HOSTNAME_VERIFICATION,
+            TAG_CLOUD_SECURE_CONNECT_BUNDLE, TAG_USE_KERBEROS, TAG_REQUEST_TIMEOUT, TAG_CONNECT_TIMEOUT,
+            TAG_TCP_NO_DELAY, TAG_KEEP_ALIVE, TAG_CONFIG_FILE, TAG_COMPLIANCE_MODE);
 
-        info[1] = new DriverPropertyInfo(TAG_PASSWORD, properties.getProperty(TAG_PASSWORD));
-        info[1].description = "The 'password' property";
+        final List<DriverPropertyInfo> info = new ArrayList<>();
+        for (String propertyName : availableProperties) {
+            info.add(buildPropertyInfo(propertyName, properties.get(propertyName)));
+        }
 
-        return info;
+        return info.toArray(new DriverPropertyInfo[]{});
     }
 
     /**

Diff for: src/main/java/com/ing/data/cassandra/jdbc/utils/DriverUtil.java

@@ -24,7 +24,9 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.sql.DriverPropertyInfo;
 import java.util.List;
+import java.util.Objects;
 import java.util.Properties;
 import java.util.stream.Collectors;
 
@@ -163,4 +165,25 @@ public static String buildMetadataList(final List<VersionedMetadata> metadataLis
             .collect(Collectors.joining(","));
     }
 
+    /**
+     * Builds an instance of {@link DriverPropertyInfo} for the given driver property and value.
+     *
+     * @param propertyName The property name.
+     * @param value        The current value of the property.
+     * @return The driver property info.
+     */
+    public static DriverPropertyInfo buildPropertyInfo(final String propertyName, final Object value) {
+        final DriverPropertyInfo propertyInfo = new DriverPropertyInfo(propertyName,
+            Objects.toString(value, StringUtils.EMPTY));
+        final String driverPropertyDefinition = "driver.properties." + propertyName;
+
+        final String propertyChoices = getDriverProperty(driverPropertyDefinition + ".choices");
+        if (StringUtils.isNotBlank(propertyChoices)) {
+            propertyInfo.choices = propertyChoices.split(",");
+        }
+        propertyInfo.required = Boolean.getBoolean(getDriverProperty(driverPropertyDefinition + ".required"));
+        propertyInfo.description = getDriverProperty(driverPropertyDefinition);
+        return propertyInfo;
+    }
+
 }

Diff for: src/main/java/com/ing/data/cassandra/jdbc/utils/ErrorConstants.java

@@ -376,6 +376,11 @@ public final class ErrorConstants {
     public static final String INVALID_PROFILE_NAME =
         "No execution profile named [%s], keep the current active profile.";
 
+    /**
+     * Error message used in any SQL exception thrown when trying to extract properties from a JDBC URL.
+     */
+    public static final String PROPERTIES_PARSING_FROM_URL_FAILED = "Failed to extract properties from the given URL.";
+
     private ErrorConstants() {
         // Private constructor to hide the public one.
     }

Diff for: src/main/resources/jdbc-driver.properties

@@ -18,4 +18,34 @@ driver.version=${project.version}
 driver.name=Cassandra JDBC Driver
 driver.jdbcVersion=4.0
 
+# The properties supported by the driver.
+driver.properties.user=The username used to connect to the database.
+driver.properties.password=The password used to connect to the database.
+driver.properties.localDatacenter=The local datacenter to use when 'DefaultLoadBalancingPolicy' (used by default) is applied.
+driver.properties.debug=Whether the debug mode is enabled.
+driver.properties.debug.choices=true,false
+driver.properties.consistencyLevel=The consistency level per connection. The consistency level defaults to 'LOCAL_ONE' as defined in the configuration reference if not specified.
+driver.properties.activeProfile=The execution profile to use when the connection to Cassandra is created.
+driver.properties.fetchSize=The default fetch size for all the queries returning result sets. This value is the number of rows the server will return in each network frame. By default, this value is set to 100.
+driver.properties.retry=The custom retry policy to apply. The value must be the full package of the policy's class implementing 'RetryPolicy' interface. By default, the driver will use 'DefaultRetryPolicy'.
+driver.properties.loadBalancing=The custom load balancing policy to apply. The value must be the full package of the policy's class implementing 'LoadBalancingPolicy' interface.
+driver.properties.reconnection=The custom reconnection policy to apply. By default, the driver will use 'ExponentialReconnectionPolicy'. If you want to use a custom policy, specify the full package of the policy's class. Make sure you always cast the policy's arguments appropriately.
+driver.properties.enableSsl=Whether the secured traffic is enabled.
+driver.properties.enableSsl.choices=true,false
+driver.properties.sslEngineFactory=The SSL engine factory to use. By default, 'DefaultSslEngineFactory' is used. The value must be the fully-qualified name of a class with a no-args constructor implementing 'SslEngineFactory' interface.
+driver.properties.hostnameVerification=Whether the validation of the server certificate's common name against the hostname of the server being connected to is enabled. By default, it's enabled if the secured traffic is enabled.
+driver.properties.hostnameVerification.choices=true,false
+driver.properties.secureConnectBundle=The fully qualified path of the cloud secure connect bundle file used to connect to an AstraDB isntance.
+driver.properties.useKerberos=Whether the Kerberos auth provider is enabled. By default, it's disabled.
+driver.properties.useKerberos.choices=true,false
+driver.properties.requestTimeout=A custom timeout for the queries in milliseconds. By default, the timeout for queries is 2 seconds.
+driver.properties.connectTimeout=A custom connection timeout in milliseconds. By default, the connection timeout is 5 seconds.
+driver.properties.tcpNoDelay=Whether the Nagle's algorithm is enabled. By default, it's enabled.
+driver.properties.tcpNoDelay.choices=true,false
+driver.properties.keepAlive=Whether the TCP keep-alive is enabled. By default, it's disabled.
+driver.properties.keepAlive.choices=true,false
+driver.properties.configFile=The Cassandra client configuration file to use.
+driver.properties.complianceMode=The compliance mode used when the connection to the database is established.
+driver.properties.complianceMode.choices=Default,Liquibase
+
 database.productName=Cassandra

Diff for: src/test/java/com/ing/data/cassandra/jdbc/DriverUnitTest.java

@@ -0,0 +1,54 @@
+/*
+ *   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 com.ing.data.cassandra.jdbc;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.approvaltests.Approvals;
+import org.approvaltests.strings.Printable;
+import org.junit.jupiter.api.Test;
+
+import java.net.InetSocketAddress;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.util.Properties;
+
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_CONNECT_TIMEOUT;
+import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.TAG_DEBUG;
+
+class DriverUnitTest extends UsingCassandraContainerTest {
+
+    private static final String KEYSPACE = "test_keyspace";
+
+    @Test
+    void givenJdbcUrlAndProperties_whenGetPropertyInfo_returnExpectedDriverPropertyInfoArray() throws Exception {
+        final InetSocketAddress contactPoint = cassandraContainer.getContactPoint();
+        final String jdbcUrl = buildJdbcUrl(contactPoint.getHostName(), contactPoint.getPort(), KEYSPACE,
+            "localdatacenter=datacenter1");
+
+        final Driver sut =  DriverManager.getDriver(jdbcUrl);
+        final Properties props = new Properties();
+        props.put(TAG_DEBUG, true);
+        props.put(TAG_CONNECT_TIMEOUT, 10000);
+        final DriverPropertyInfo[] result = sut.getPropertyInfo(jdbcUrl, props);
+        final Printable<DriverPropertyInfo>[] printableResult = Printable.create(info ->
+            info.name + ": " + info.value
+                + "\n\t" + info.description
+                + "\n\tchoices: " + ArrayUtils.toString(info.choices, "n/a")
+                + "\n\trequired: " + info.required
+        , result);
+        Approvals.verifyAll("", printableResult);
+    }
+
+}

Diff for: src/test/java/com/ing/data/cassandra/jdbc/PackageSettings.java

@@ -0,0 +1,24 @@
+/*
+ *   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 com.ing.data.cassandra.jdbc;
+
+/**
+ * TestApprovals configuration.
+ */
+public class PackageSettings {
+
+    public static String ApprovalBaseDirectory = "../resources";
+    public static String UseApprovalSubdirectory = "approvals";
+
+}

Diff for: src/test/java/com/ing/data/cassandra/jdbc/UtilsUnitTest.java

@@ -25,6 +25,7 @@
 import org.junit.jupiter.params.provider.ValueSource;
 import org.semver4j.Semver;
 
+import java.sql.DriverPropertyInfo;
 import java.sql.SQLException;
 import java.sql.SQLNonTransientConnectionException;
 import java.sql.SQLSyntaxErrorException;
@@ -40,6 +41,7 @@
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.CASSANDRA_4;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.CASSANDRA_5;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.buildMetadataList;
+import static com.ing.data.cassandra.jdbc.utils.DriverUtil.buildPropertyInfo;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.existsInDatabaseVersion;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.getDriverProperty;
 import static com.ing.data.cassandra.jdbc.utils.DriverUtil.safeParseVersion;
@@ -68,8 +70,10 @@
 import static com.ing.data.cassandra.jdbc.utils.JdbcUrlUtil.parseURL;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasItems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -330,4 +334,29 @@ void testBuildMetadataList() {
             new BasicVersionedMetadata("c", CASSANDRA_5)
         ), CASSANDRA_4));
     }
+
+    @Test
+    void testBuildPropertyInfo() {
+        DriverPropertyInfo propertyInfo = buildPropertyInfo("prop", null);
+        assertEquals("prop", propertyInfo.name);
+        assertEquals(StringUtils.EMPTY, propertyInfo.value);
+        assertFalse(propertyInfo.required);
+        assertEquals(StringUtils.EMPTY, propertyInfo.description);
+        assertNull(propertyInfo.choices);
+
+        propertyInfo = buildPropertyInfo("propInt", 1500);
+        assertEquals("propInt", propertyInfo.name);
+        assertEquals("1500", propertyInfo.value);
+
+        propertyInfo = buildPropertyInfo("propStr", "abc");
+        assertEquals("propStr", propertyInfo.name);
+        assertEquals("abc", propertyInfo.value);
+
+        propertyInfo = buildPropertyInfo("keepAlive", true);
+        assertEquals("keepAlive", propertyInfo.name);
+        assertEquals(Boolean.TRUE.toString(), propertyInfo.value);
+        assertFalse(propertyInfo.required);
+        assertEquals("Whether the TCP keep-alive is enabled. By default, it's disabled.", propertyInfo.description);
+        assertThat(Arrays.asList(propertyInfo.choices), hasItems("true", "false"));
+    }
 }