SNOW-1016470: Increase code coverage in JDBC part1

src/main/java/net/snowflake/client/core/ExecTimeTelemetryData.java

@@ -154,7 +154,7 @@ public String generateTelemetry() {
       value.put("ProcessResultChunkStart", this.processResultChunk.getStart());
       value.put("ProcessResultChunkEnd", this.processResultChunk.getEnd());
       value.put("CreateResultSetStart", this.createResultSet.getStart());
-      value.put("CreatResultSetEnd", this.createResultSet.getEnd());
+      value.put("CreateResultSetEnd", this.createResultSet.getEnd());
       value.put("QueryEnd", this.query.getEnd());
       value.put("BatchID", this.batchId);
       value.put("QueryID", this.queryId);

src/test/java/net/snowflake/client/TestUtil.java

@@ -7,12 +7,15 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
+import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Arrays;
 import java.util.List;
 import java.util.regex.Pattern;
 import net.snowflake.client.core.SFException;
+import net.snowflake.client.jdbc.SnowflakeLoggedFeatureNotSupportedException;
 import net.snowflake.client.jdbc.SnowflakeUtil;
 import net.snowflake.client.log.SFLogger;
 import net.snowflake.client.log.SFLoggerFactory;
@@ -128,4 +131,17 @@ public static void withRandomSchema(
       statement.execute("DROP SCHEMA " + customSchema);
     }
   }
+
+  public interface MethodRaisesSQLException {
+    void run() throws SQLException;
+  }
+
+  public static void expectSnowflakeLoggedFeatureNotSupportedException(MethodRaisesSQLException f) {
+    try {
+      f.run();
+      fail("must raise exception");
+    } catch (SQLException ex) {
+      assertTrue(ex instanceof SnowflakeLoggedFeatureNotSupportedException);
+    }
+  }
 }

src/test/java/net/snowflake/client/config/SFClientConfigParserTest.java

@@ -47,6 +47,7 @@ public void testLoadSFClientConfigValidPath() throws IOException {
         SFClientConfigParser.loadSFClientConfig(configFilePath.toString());
     assertEquals("info", actualConfig.getCommonProps().getLogLevel());
     assertEquals("/jdbc.log", actualConfig.getCommonProps().getLogPath());
+    assertEquals("config.json", actualConfig.getConfigFilePath());
   }
 
   @Test

src/test/java/net/snowflake/client/core/ExecTimeTelemetryDataTest.java

@@ -0,0 +1,84 @@
+package net.snowflake.client.core;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import net.minidev.json.JSONObject;
+import net.minidev.json.parser.JSONParser;
+import net.minidev.json.parser.ParseException;
+import net.snowflake.client.jdbc.telemetryOOB.TelemetryService;
+import org.junit.Test;
+
+public class ExecTimeTelemetryDataTest {
+
+  @Test
+  public void testExecTimeTelemetryData() throws ParseException {
+    ExecTimeTelemetryData execTimeTelemetryData = new ExecTimeTelemetryData();
+    execTimeTelemetryData.sendData = true;
+    execTimeTelemetryData.setBindStart();
+    execTimeTelemetryData.setOCSPStatus(true);
+    execTimeTelemetryData.setBindEnd();
+    execTimeTelemetryData.setHttpClientStart();
+    execTimeTelemetryData.setHttpClientEnd();
+    execTimeTelemetryData.setGzipStart();
+    execTimeTelemetryData.setGzipEnd();
+    execTimeTelemetryData.setQueryEnd();
+    execTimeTelemetryData.setQueryId("queryid");
+    execTimeTelemetryData.setProcessResultChunkStart();
+    execTimeTelemetryData.setProcessResultChunkEnd();
+    execTimeTelemetryData.setResponseIOStreamStart();
+    execTimeTelemetryData.setResponseIOStreamEnd();
+    execTimeTelemetryData.setCreateResultSetStart();
+    execTimeTelemetryData.setCreateResultSetEnd();
+    execTimeTelemetryData.incrementRetryCount();
+    execTimeTelemetryData.setRequestId("mockId");
+    execTimeTelemetryData.addRetryLocation("retry");
+
+    String telemetry = execTimeTelemetryData.generateTelemetry();
+    JSONParser parser = new JSONParser(JSONParser.MODE_JSON_SIMPLE);
+    JSONObject json = (JSONObject) parser.parse(telemetry);
+    assertNotNull(json.get("BindStart"));
+    assertNotNull(json.get("BindEnd"));
+    assertEquals(json.get("ocspEnabled"), true);
+    assertNotNull(json.get("HttpClientStart"));
+    assertNotNull(json.get("HttpClientEnd"));
+    assertNotNull(json.get("GzipStart"));
+    assertNotNull(json.get("GzipEnd"));
+    assertNotNull(json.get("QueryEnd"));
+    assertEquals(json.get("QueryID"), "queryid");
+    assertNotNull(json.get("ProcessResultChunkStart"));
+    assertNotNull(json.get("ProcessResultChunkEnd"));
+    assertNotNull(json.get("ResponseIOStreamStart"));
+    assertNotNull(json.get("CreateResultSetStart"));
+    assertNotNull(json.get("CreateResultSetEnd"));
+    assertNotNull(json.get("ElapsedQueryTime"));
+    assertNotNull(json.get("ElapsedResultProcessTime"));
+    assertNull(json.get("QueryFunction"));
+    assertNull(json.get("BatchID"));
+    assertEquals(((Long) json.get("RetryCount")).intValue(), 1);
+    assertEquals(json.get("RequestID"), "mockId");
+    assertEquals(json.get("RetryLocations"), "retry");
+    assertEquals(json.get("Urgent"), true);
+    assertEquals(json.get("eventType"), "ExecutionTimeRecord");
+  }
+
+  @Test
+  public void testRetryLocation() throws ParseException {
+    TelemetryService.enableHTAP();
+    ExecTimeTelemetryData execTimeTelemetryData =
+        new ExecTimeTelemetryData("queryFunction", "batchId");
+    execTimeTelemetryData.addRetryLocation("hello");
+    execTimeTelemetryData.addRetryLocation("world");
+    execTimeTelemetryData.sendData = true;
+    String telemetry = execTimeTelemetryData.generateTelemetry();
+
+    JSONParser parser = new JSONParser(JSONParser.MODE_JSON_SIMPLE);
+    JSONObject json = (JSONObject) parser.parse(telemetry);
+    assertEquals(json.get("QueryFunction"), "queryFunction");
+    assertEquals(json.get("BatchID"), "batchId");
+    assertNotNull(json.get("QueryStart"));
+    assertEquals(json.get("RetryLocations"), "hello, world");
+    TelemetryService.disableHTAP();
+  }
+}

src/test/java/net/snowflake/client/core/QueryContextCacheTest.java

@@ -6,6 +6,9 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Test;
 
@@ -217,6 +220,11 @@ public void testSerializeRequestAndDeserializeResponseDataWithNullContext() thro
 
     qcc.deserializeQueryContextDTO(requestData);
     assertCacheDataWithContext(null);
+
+    QueryContextCache mockQcc = spy(qcc);
+    mockQcc.deserializeQueryContextDTO(null);
+    verify(mockQcc).clearCache();
+    verify(mockQcc, times(2)).logCacheEntries();
   }
 
   private void assertCacheData() {

src/test/java/net/snowflake/client/core/SQLInputOutputTest.java

@@ -0,0 +1,42 @@
+package net.snowflake.client.core;
+
+import static net.snowflake.client.TestUtil.expectSnowflakeLoggedFeatureNotSupportedException;
+import static org.mockito.Mockito.mock;
+
+import java.sql.SQLData;
+import org.junit.Test;
+
+public class SQLInputOutputTest {
+
+  @Test
+  public void testBaseSQLUnSupportedException() {
+    BaseSqlInput sqlInput = new ArrowSqlInput(null, null, null, null);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readCharacterStream);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readAsciiStream);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readBinaryStream);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readRef);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readBlob);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readClob);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readArray);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readURL);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readNClob);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readNString);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readSQLXML);
+    expectSnowflakeLoggedFeatureNotSupportedException(sqlInput::readRowId);
+  }
+
+  @Test
+  public void testJsonSqlOutPutUnSupportedTest() {
+    JsonSqlOutput sqloutput = new JsonSqlOutput(mock(SQLData.class), mock(SFBaseSession.class));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeRef(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeBlob(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeClob(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeStruct(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeArray(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeURL(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeNString(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeNClob(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeRowId(null));
+    expectSnowflakeLoggedFeatureNotSupportedException(() -> sqloutput.writeSQLXML(null));
+  }
+}

src/test/java/net/snowflake/client/core/bind/BindExceptionTest.java

@@ -0,0 +1,23 @@
+package net.snowflake.client.core.bind;
+
+import static org.junit.Assert.assertEquals;
+
+import net.snowflake.client.jdbc.telemetry.TelemetryField;
+import org.junit.Test;
+
+public class BindExceptionTest {
+
+  @Test
+  public void testBindExceptionType() {
+    assertEquals(BindException.Type.SERIALIZATION.field, TelemetryField.FAILED_BIND_SERIALIZATION);
+    assertEquals(BindException.Type.UPLOAD.field, TelemetryField.FAILED_BIND_UPLOAD);
+    assertEquals(BindException.Type.OTHER.field, TelemetryField.FAILED_BIND_OTHER);
+  }
+
+  @Test
+  public void testBindExceptionConstructor() {
+    BindException exception = new BindException("testException", BindException.Type.SERIALIZATION);
+    assertEquals(exception.getMessage(), "testException");
+    assertEquals(exception.type.field, TelemetryField.FAILED_BIND_SERIALIZATION);
+  }
+}

src/test/java/net/snowflake/client/jdbc/BaseJDBCTest.java

@@ -35,6 +35,7 @@
 import javax.xml.transform.Result;
 import javax.xml.transform.Source;
 import net.snowflake.client.AbstractDriverIT;
+import net.snowflake.client.core.SFException;
 
 public class BaseJDBCTest extends AbstractDriverIT {
   // Test UUID unique per session
@@ -44,6 +45,10 @@ protected interface MethodRaisesSQLException {
     void run() throws SQLException;
   }
 
+  protected interface MethodRaisesSFException {
+    void run() throws SFException;
+  }
+
   protected interface MethodRaisesSQLClientInfoException {
     void run() throws SQLClientInfoException;
   }

src/test/java/net/snowflake/client/jdbc/ResultSetAlreadyClosedIT.java

@@ -22,8 +22,9 @@ public class ResultSetAlreadyClosedIT extends BaseJDBCTest {
   @Test
   public void testQueryResultSetAlreadyClosed() throws Throwable {
     try (Connection connection = getConnection();
-        Statement statement = connection.createStatement();
-        ResultSet resultSet = statement.executeQuery("select 1")) {
+        Statement statement = connection.createStatement()) {
+      ResultSet resultSet = statement.executeQuery("select 1");
+      resultSet.close();
       checkAlreadyClosed(resultSet);
     }
   }
@@ -44,9 +45,18 @@ public void testMetadataResultSetAlreadyClosed() throws Throwable {
   }
 
   @Test
-  public void testEmptyResultSetAlreadyClosed() throws Throwable {
-    try (ResultSet resultSet = new SnowflakeResultSetV1.EmptyResultSet()) {
+  public void testResultSetAlreadyClosed() throws Throwable {
+    try (Connection connection = getConnection();
+        Statement statement = connection.createStatement();
+        ResultSet resultSet = statement.executeQuery("SELECT 1")) {
       checkAlreadyClosed(resultSet);
+    }
+  }
+
+  @Test
+  public void testEmptyResultSetAlreadyClosed() throws Throwable {
+    try (SnowflakeResultSetV1.EmptyResultSet resultSet =
+        new SnowflakeResultSetV1.EmptyResultSet()) {
       checkAlreadyClosedEmpty(resultSet);
     }
   }
@@ -68,7 +78,7 @@ private void checkAlreadyClosed(ResultSet resultSet) throws SQLException {
     expectResultSetAlreadyClosedException(() -> resultSet.getDouble(1));
     expectResultSetAlreadyClosedException(() -> resultSet.getBigDecimal(1));
     expectResultSetAlreadyClosedException(() -> resultSet.getBytes(1));
-    expectResultSetAlreadyClosedException(() -> resultSet.getString(1));
+    expectResultSetAlreadyClosedException(() -> resultSet.getDate(1));
     expectResultSetAlreadyClosedException(() -> resultSet.getDate(1));
     expectResultSetAlreadyClosedException(() -> resultSet.getTime(1));
     expectResultSetAlreadyClosedException(() -> resultSet.getTimestamp(1));
@@ -105,7 +115,13 @@ private void checkAlreadyClosed(ResultSet resultSet) throws SQLException {
     expectResultSetAlreadyClosedException(() -> resultSet.getBigDecimal("col1", 38));
 
     expectResultSetAlreadyClosedException(resultSet::getWarnings);
+    expectResultSetAlreadyClosedException(
+        () -> resultSet.unwrap(SnowflakeBaseResultSet.class).getWarnings());
+
     expectResultSetAlreadyClosedException(resultSet::clearWarnings);
+    expectResultSetAlreadyClosedException(
+        () -> resultSet.unwrap(SnowflakeBaseResultSet.class).clearWarnings());
+
     expectResultSetAlreadyClosedException(resultSet::getMetaData);
 
     expectResultSetAlreadyClosedException(() -> resultSet.findColumn("col1"));
@@ -119,11 +135,20 @@ private void checkAlreadyClosed(ResultSet resultSet) throws SQLException {
     expectResultSetAlreadyClosedException(
         () -> resultSet.setFetchDirection(ResultSet.FETCH_FORWARD));
     expectResultSetAlreadyClosedException(() -> resultSet.setFetchSize(10));
+    expectResultSetAlreadyClosedException(
+        () -> resultSet.unwrap(SnowflakeBaseResultSet.class).setFetchSize(10));
+
     expectResultSetAlreadyClosedException(resultSet::getFetchDirection);
     expectResultSetAlreadyClosedException(resultSet::getFetchSize);
     expectResultSetAlreadyClosedException(resultSet::getType);
     expectResultSetAlreadyClosedException(resultSet::getConcurrency);
+    expectResultSetAlreadyClosedException(
+        resultSet.unwrap(SnowflakeBaseResultSet.class)::getConcurrency);
+
     expectResultSetAlreadyClosedException(resultSet::getHoldability);
+    expectResultSetAlreadyClosedException(
+        resultSet.unwrap(SnowflakeBaseResultSet.class)::getHoldability);
+
     expectResultSetAlreadyClosedException(resultSet::getStatement);
   }
 
@@ -133,7 +158,8 @@ private void checkAlreadyClosed(ResultSet resultSet) throws SQLException {
    * @param resultSet
    * @throws SQLException
    */
-  private void checkAlreadyClosedEmpty(ResultSet resultSet) throws SQLException {
+  private void checkAlreadyClosedEmpty(SnowflakeResultSetV1.EmptyResultSet resultSet)
+      throws SQLException {
     resultSet.close();
     resultSet.close(); // second close won't raise exception
     assertTrue(resultSet.isClosed());