Add JDBC spec integration tests with fake service record-replay (#1212)

## Summary

- Add 6 new fake service integration test classes (40 tests total) to
close critical JDBC spec coverage gaps
- All tests use the existing WireMock-based record-replay infrastructure
in SEA mode
- Tests are recorded against production and verified in replay mode (no
token needed for CI)
- WireMock stub recordings are committed alongside the test code

## Coverage Analysis

### Before (Baseline)
| Metric | Value |
|--------|-------|
| Total Applicable JDBC Methods | 328 |
| Methods with Integration Tests | 44 |
| **Integration Test Coverage** | **13.4%** |

### After (This PR)
| Metric | Value |
|--------|-------|
| Total Applicable JDBC Methods | 328 |
| Methods with Integration Tests | ~70 |
| **Integration Test Coverage** | **~21.3%** |

### New Methods Covered

| Category | New Methods Tested |
|----------|-------------------|
| **Statement** | `getResultSet()`, `getUpdateCount()`,
`getMoreResults()`, `addBatch(String)`, `executeBatch()`, `clearBatch()`
|
| **PreparedStatement** | `addBatch()`, `executeBatch()`,
`clearBatch()`, method mismatch rejection for `execute(String)`,
`executeQuery(String)`, `executeUpdate(String)` |
| **ResultSet** | `isBeforeFirst()`, `isFirst()`, `getRow()`,
`getType()`, `getConcurrency()`, `getFetchSize()`, `setFetchSize(int)`,
`getFetchDirection()` |
| **Connection** | `isClosed()`, `isValid(int)`, `getCatalog()`,
`getSchema()` |
| **Configuration** | `NonRowcountQueryPrefixes` behavior for
`execute()` and `executeQuery()` with DML |


## Test plan
- [x] All 40 tests pass in RECORD mode against production (e2-dogfood)
- [x] All 40 tests pass in REPLAY mode (no network calls, no token
needed)
- [x] Compilation succeeds with `mvn test-compile`
- [ ] Verify existing fake service tests still pass in replay mode

NO_CHANGELOG=true

---------

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

Author: gopalldb

docs/JDBC_METHOD_INVENTORY.md

@@ -1303,7 +1303,7 @@ void testGetObjectWithClassType_NullString_ReturnsNull() throws SQLException {
     assertNull(resultSet.getObject(1, String.class));
     assertTrue(resultSet.wasNull());
   }
-  
+
   // --- Tests for TelemetryCollector caching in next() ---
   private DatabricksResultSet getResultSetWithTelemetry() throws SQLException {
     DatabricksConnection mockConnection = mock(DatabricksConnection.class);

docs/JDBC_SPEC_COVERAGE_ANALYSIS.md

@@ -1,6 +1,7 @@
 package com.databricks.jdbc.integration.fakeservice.tests;
 
 import static com.databricks.jdbc.integration.IntegrationTestUtil.*;
+import static org.junit.jupiter.api.Assertions.*;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import com.databricks.jdbc.common.DatabricksJdbcUrlParams;
@@ -82,6 +83,50 @@ void testPATinOAuthTokenPassThrough() throws Exception {
     conn.close();
   }
 
+  // --- Connection management tests ---
+
+  @Test
+  void testIsClosed_NewConnection() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+    assertFalse(conn.isClosed(), "Newly created connection should not be closed");
+
+    conn.close();
+    assertTrue(conn.isClosed(), "Connection should be closed after close()");
+  }
+
+  @Test
+  void testIsValid_ActiveConnection() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+
+    // isValid with a positive timeout should return true for an active connection
+    assertTrue(conn.isValid(5), "Active connection should be valid");
+
+    conn.close();
+    assertFalse(conn.isValid(5), "Closed connection should not be valid");
+  }
+
+  @Test
+  void testGetCatalog_ReturnsNonNull() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+
+    String catalog = conn.getCatalog();
+    assertNotNull(catalog, "getCatalog() should return non-null for active connection");
+    assertFalse(catalog.isEmpty(), "getCatalog() should return non-empty string");
+
+    conn.close();
+  }
+
+  @Test
+  void testGetSchema_ReturnsNonNull() throws SQLException {
+    Connection conn = getValidJDBCConnection();
+
+    String schema = conn.getSchema();
+    assertNotNull(schema, "getSchema() should return non-null for active connection");
+    assertFalse(schema.isEmpty(), "getSchema() should return non-empty string");
+
+    conn.close();
+  }
+
   private Properties createConnectionProperties(Properties extraProps) {
     Properties connProps = new Properties();
     connProps.putAll(extraProps);

src/test/java/com/databricks/jdbc/api/impl/DatabricksResultSetTest.java

@@ -6,6 +6,7 @@
 import com.databricks.jdbc.api.impl.DatabricksConnection;
 import com.databricks.jdbc.common.DatabricksClientType;
 import com.databricks.jdbc.exception.DatabricksSQLException;
+import com.databricks.jdbc.exception.DatabricksSQLFeatureNotImplementedException;
 import com.databricks.jdbc.exception.DatabricksSQLFeatureNotSupportedException;
 import com.databricks.jdbc.integration.fakeservice.AbstractFakeServiceIntegrationTests;
 import com.databricks.jdbc.integration.fakeservice.FakeServiceConfigLoader;
@@ -136,4 +137,94 @@ void testCallingUnsupportedSQLFeature() {
   private void getConnection(String url) throws SQLException {
     DriverManager.getConnection(url, "username", "password");
   }
+
+  // --- Method mismatch tests (executeQuery with DML, executeUpdate with SELECT) ---
+
+  @Test
+  void testExecuteQuery_WithInsert_ThrowsSQLException() throws SQLException {
+    String tableName = "mismatch_insert_table";
+    setupDatabaseTable(connection, tableName);
+
+    Statement stmt = connection.createStatement();
+    String insertSQL =
+        "INSERT INTO "
+            + getFullyQualifiedTableName(tableName)
+            + " (id, col1, col2) VALUES (1, 'a', 'b')";
+
+    DatabricksSQLException e =
+        assertThrows(DatabricksSQLException.class, () -> stmt.executeQuery(insertSQL));
+    assertTrue(
+        e.getMessage().contains("ResultSet was expected but not generated"),
+        "Error message should indicate no ResultSet was generated, got: " + e.getMessage());
+
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testExecuteQuery_WithUpdate_ThrowsSQLException() throws SQLException {
+    String tableName = "mismatch_update_table";
+    setupDatabaseTable(connection, tableName);
+    insertTestData(connection, tableName);
+
+    Statement stmt = connection.createStatement();
+    String updateSQL =
+        "UPDATE " + getFullyQualifiedTableName(tableName) + " SET col1 = 'updated' WHERE id = 1";
+
+    DatabricksSQLException e =
+        assertThrows(DatabricksSQLException.class, () -> stmt.executeQuery(updateSQL));
+    assertTrue(
+        e.getMessage().contains("ResultSet was expected but not generated"),
+        "Error message should indicate no ResultSet was generated, got: " + e.getMessage());
+
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testExecuteQuery_WithDelete_ThrowsSQLException() throws SQLException {
+    String tableName = "mismatch_delete_table";
+    setupDatabaseTable(connection, tableName);
+    insertTestData(connection, tableName);
+
+    Statement stmt = connection.createStatement();
+    String deleteSQL = "DELETE FROM " + getFullyQualifiedTableName(tableName) + " WHERE id = 1";
+
+    DatabricksSQLException e =
+        assertThrows(DatabricksSQLException.class, () -> stmt.executeQuery(deleteSQL));
+    assertTrue(
+        e.getMessage().contains("ResultSet was expected but not generated"),
+        "Error message should indicate no ResultSet was generated, got: " + e.getMessage());
+
+    deleteTable(connection, tableName);
+  }
+
+  @Test
+  void testExecuteUpdate_WithSelect_ThrowsSQLException() throws SQLException {
+    Statement stmt = connection.createStatement();
+
+    assertThrows(
+        DatabricksSQLException.class,
+        () -> stmt.executeUpdate("SELECT 1 AS num"),
+        "executeUpdate() with SELECT should throw because result has no update count column");
+  }
+
+  @Test
+  void testPreparedStatement_StatementMethodsWithSQL_ThrowException() throws SQLException {
+    String selectSQL = "SELECT 1";
+    PreparedStatement pstmt = connection.prepareStatement(selectSQL);
+
+    assertThrows(
+        DatabricksSQLFeatureNotImplementedException.class,
+        () -> pstmt.executeQuery("SELECT 2"),
+        "PreparedStatement.executeQuery(String) should throw");
+
+    assertThrows(
+        DatabricksSQLFeatureNotImplementedException.class,
+        () -> pstmt.executeUpdate("INSERT INTO dummy VALUES (1)"),
+        "PreparedStatement.executeUpdate(String) should throw");
+
+    assertThrows(
+        DatabricksSQLFeatureNotImplementedException.class,
+        () -> pstmt.execute("SELECT 3"),
+        "PreparedStatement.execute(String) should throw");
+  }
 }