Add 56 JDBC spec integration tests with comprehensive DatabaseMetaData coverage (#1216)

## Summary
- Adds **56 new integration tests** across 5 test files to close JDBC
spec coverage gaps
- Includes comprehensive **DatabaseMetaData testing** (~180 assertions
covering all boolean/int/string property methods)
- All tests use the WireMock record-replay fake service infrastructure
with both SEA and Thrift recordings

### New tests by file:
| File | New Tests | Coverage Area |
|------|-----------|--------------|
| `MetadataIntegrationTests` | 25 | All boolean properties, string/int
properties, ResultSet-returning methods (getTypeInfo, getProcedures,
getFunctions, getImportedKeys, getExportedKeys, getCrossReference,
etc.), wrapper/lifecycle |
| `ResultSetIntegrationTests` | 10 | Type getters: getBoolean, getByte,
getShort, getLong, getFloat, getDouble, getBigDecimal, getDate,
getTimestamp, getObject |
| `PreparedStatementIntegrationTests` | 7 | Type setters: setBoolean,
setLong, setFloat, setDouble, setBigDecimal, setDate, setTimestamp |
| `ExecutionIntegrationTests` | 4 | Statement utilities: fetchDirection,
enquoteLiteral, enquoteIdentifier, isSimpleIdentifier |
| `ConnectionIntegrationTests` | 3 | Connection attributes: autoCommit
default, isReadOnly, transactionIsolation |

### Verification results:
- **SEA REPLAY**: All tests pass (0 failures)
- **Thrift REPLAY**: All tests pass (8 metadata tests skipped as
SEA-only due to Thrift recording limitations)

## Test plan
- [x] All 56 new tests pass in SEA REPLAY mode
- [x] All tests pass in Thrift REPLAY mode (with expected skips)
- [x] No regressions in existing tests
- [x] WireMock recordings committed for both SEA and Thrift modes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

NO_CHANGELOG=true

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: gopalldb

src/test/java/com/databricks/jdbc/integration/fakeservice/tests/ConnectionIntegrationTests.java

@@ -113,6 +113,17 @@ void testGetCatalog_ReturnsNonNull() throws SQLException {
     conn.close();
   }
 
+  // --- Transaction and connection attribute tests ---
+
+  @Test
+  void testAutoCommit_DefaultIsTrue() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+
+    assertTrue(conn.getAutoCommit(), "Default autoCommit should be true");
+
+    conn.close();
+  }
+
   @Test
   void testGetSchema_ReturnsNonNull() throws SQLException {
     Connection conn = getValidJDBCConnection();
@@ -124,6 +135,16 @@ void testGetSchema_ReturnsNonNull() throws SQLException {
     conn.close();
   }
 
+  @Test
+  void testIsReadOnly_Default() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+
+    boolean readOnly = conn.isReadOnly();
+    assertFalse(readOnly, "Default connection should not be read-only");
+
+    conn.close();
+  }
+
   @Test
   void testGetMetaData_ReturnsNonNull() throws SQLException {
     Connection conn = getValidJDBCConnection();
@@ -159,6 +180,22 @@ void testGetClientInfo_ReturnsProperties() throws SQLException {
     conn.close();
   }
 
+  @Test
+  void testGetTransactionIsolation() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+
+    int isolation = conn.getTransactionIsolation();
+    assertTrue(
+        isolation == Connection.TRANSACTION_NONE
+            || isolation == Connection.TRANSACTION_READ_UNCOMMITTED
+            || isolation == Connection.TRANSACTION_READ_COMMITTED
+            || isolation == Connection.TRANSACTION_REPEATABLE_READ
+            || isolation == Connection.TRANSACTION_SERIALIZABLE,
+        "Transaction isolation should be a valid JDBC constant");
+
+    conn.close();
+  }
+
   private Properties createConnectionProperties(Properties extraProps) {
     Properties connProps = new Properties();
     connProps.putAll(extraProps);

src/test/java/com/databricks/jdbc/integration/fakeservice/tests/ExecutionIntegrationTests.java

@@ -278,6 +278,57 @@ void testExecuteAsyncStatement() throws Exception {
         rs2.unwrap(IDatabricksResultSet.class).getStatementStatus().getState());
   }
 
+  // --- Statement property tests ---
+
+  @Test
+  void testStatement_FetchDirection() throws SQLException {
+    Statement stmt = connection.createStatement();
+
+    // Default should be FETCH_FORWARD
+    assertEquals(
+        ResultSet.FETCH_FORWARD,
+        stmt.getFetchDirection(),
+        "Default fetch direction should be FETCH_FORWARD");
+
+    // Setting FETCH_FORWARD should work
+    stmt.setFetchDirection(ResultSet.FETCH_FORWARD);
+    assertEquals(ResultSet.FETCH_FORWARD, stmt.getFetchDirection());
+
+    stmt.close();
+  }
+
+  @Test
+  void testStatement_EnquoteLiteral() throws SQLException {
+    Statement stmt = connection.createStatement();
+
+    String result = stmt.enquoteLiteral("test");
+    assertNotNull(result, "enquoteLiteral should return non-null");
+    assertTrue(result.contains("test"), "enquoteLiteral should contain the original string");
+
+    stmt.close();
+  }
+
+  @Test
+  void testStatement_EnquoteIdentifier() throws SQLException {
+    Statement stmt = connection.createStatement();
+
+    String result = stmt.enquoteIdentifier("my_column", false);
+    assertNotNull(result, "enquoteIdentifier should return non-null");
+
+    stmt.close();
+  }
+
+  @Test
+  void testStatement_IsSimpleIdentifier() throws SQLException {
+    Statement stmt = connection.createStatement();
+
+    assertTrue(stmt.isSimpleIdentifier("simple_name"), "simple_name should be a simple identifier");
+    assertFalse(
+        stmt.isSimpleIdentifier("has space"), "'has space' should not be a simple identifier");
+
+    stmt.close();
+  }
+
   // --- Statement lifecycle and property tests ---
 
   @Test

src/test/java/com/databricks/jdbc/integration/fakeservice/tests/MetadataIntegrationTests.java

@@ -289,6 +289,141 @@ void testSetObject(
     deleteTable(connection, tableName);
   }
 
+  // --- PreparedStatement type setter tests ---
+
+  @Test
+  void testSetBoolean() throws SQLException {
+    String tableName = "pstmt_set_boolean_table";
+    String createSQL =
+        "CREATE TABLE " + getFullyQualifiedTableName(tableName) + " (id INT, flag BOOLEAN)";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, flag) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setBoolean(2, true);
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT flag FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    assertTrue(rs.getBoolean("flag"), "Boolean value should be true");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testSetLong() throws SQLException {
+    String tableName = "pstmt_set_long_table";
+    String createSQL =
+        "CREATE TABLE " + getFullyQualifiedTableName(tableName) + " (id INT, big_val BIGINT)";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, big_val) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setLong(2, 9876543210L);
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT big_val FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    assertEquals(9876543210L, rs.getLong("big_val"), "Long value should match");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testSetFloat() throws SQLException {
+    String tableName = "pstmt_set_float_table";
+    String createSQL =
+        "CREATE TABLE " + getFullyQualifiedTableName(tableName) + " (id INT, float_val FLOAT)";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, float_val) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setFloat(2, 3.14f);
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT float_val FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    assertEquals(3.14f, rs.getFloat("float_val"), 0.01f, "Float value should match");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testSetDouble() throws SQLException {
+    String tableName = "pstmt_set_double_table";
+    String createSQL =
+        "CREATE TABLE " + getFullyQualifiedTableName(tableName) + " (id INT, dbl_val DOUBLE)";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, dbl_val) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setDouble(2, 2.718281828);
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT dbl_val FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    assertEquals(2.718281828, rs.getDouble("dbl_val"), 0.0001, "Double value should match");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testSetBigDecimal() throws SQLException {
+    String tableName = "pstmt_set_bigdecimal_table";
+    String createSQL =
+        "CREATE TABLE "
+            + getFullyQualifiedTableName(tableName)
+            + " (id INT, dec_val DECIMAL(15, 4))";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, dec_val) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setBigDecimal(2, new BigDecimal("12345.6789"));
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT dec_val FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    assertEquals(
+        new BigDecimal("12345.6789"), rs.getBigDecimal("dec_val"), "BigDecimal value should match");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
   // --- PreparedStatement enhancement tests ---
 
   @Test
@@ -350,6 +485,62 @@ void testSetNull_WithIntType() throws SQLException {
     deleteTable(connection, tableName);
   }
 
+  @Test
+  void testSetDate() throws SQLException {
+    String tableName = "pstmt_set_date_table";
+    String createSQL =
+        "CREATE TABLE " + getFullyQualifiedTableName(tableName) + " (id INT, date_val DATE)";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    Date testDate = Date.valueOf("2024-06-15");
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, date_val) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setDate(2, testDate);
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT date_val FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    assertEquals(testDate, rs.getDate("date_val"), "Date value should match");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testSetTimestamp() throws SQLException {
+    String tableName = "pstmt_set_timestamp_table";
+    String createSQL =
+        "CREATE TABLE " + getFullyQualifiedTableName(tableName) + " (id INT, ts_val TIMESTAMP)";
+    setupDatabaseTable(connection, tableName, createSQL);
+
+    Timestamp testTs = Timestamp.valueOf("2024-06-15 10:30:00");
+    String insertSQL =
+        "INSERT INTO " + getFullyQualifiedTableName(tableName) + " (id, ts_val) VALUES (?, ?)";
+    try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
+      pstmt.setInt(1, 1);
+      pstmt.setTimestamp(2, testTs);
+      assertEquals(1, pstmt.executeUpdate());
+    }
+
+    ResultSet rs =
+        executeQuery(
+            connection,
+            "SELECT ts_val FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1");
+    assertTrue(rs.next());
+    Timestamp retrieved = rs.getTimestamp("ts_val");
+    assertNotNull(retrieved, "Timestamp should not be null");
+    assertEquals(testTs, retrieved, "Timestamp value should match");
+
+    rs.close();
+    deleteTable(connection, tableName);
+  }
+
   @Test
   void testSetObject_WithoutSqlType() throws SQLException {
     String tableName = "pstmt_setobj_notype_table";