SNOW-1016470: Increase code coverage to at least 90% in JDBC

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

@@ -26,6 +26,9 @@ public class URLUtil {
   static final Pattern pattern = Pattern.compile(validURLPattern);
 
   public static boolean isValidURL(String url) {
+    if (url == null) {
+      return false;
+    }
     try {
       Matcher matcher = pattern.matcher(url);
       return matcher.find();

src/main/java/net/snowflake/client/jdbc/cloud/storage/StorageProviderException.java

@@ -29,14 +29,14 @@ public Exception getOriginalProviderException() {
 
   /**
    * Returns true if this is an exception corresponding to a HTTP 404 error returned by the storage
-   * provider
+   * provider.
    *
    * @return true if the specified exception is an AmazonServiceException instance and if it was
    *     thrown because of a 404, false otherwise.
    */
   public boolean isServiceException404() {
-    if ((Exception) this instanceof AmazonServiceException) {
-      AmazonServiceException asEx = (AmazonServiceException) ((java.lang.Exception) this);
+    if (getCause() instanceof AmazonServiceException) {
+      AmazonServiceException asEx = (AmazonServiceException) getCause();
       return (asEx.getStatusCode() == HttpStatus.SC_NOT_FOUND);
     }
 

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

@@ -8,6 +8,7 @@
 import static net.snowflake.client.jdbc.SnowflakeUtil.systemSetEnv;
 import static net.snowflake.client.jdbc.SnowflakeUtil.systemUnsetEnv;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -141,4 +142,64 @@ public void testConvertToWindowsPath() {
         mockCloudPrefix + resultWindowsPath,
         convertToWindowsPath(mockCloudPrefix + mockWindowsPath));
   }
+
+  @Test
+  void testSFClientConfigConstructorAndAccessors() {
+    SFClientConfig.CommonProps props = new SFClientConfig.CommonProps();
+    props.setLogLevel("DEBUG");
+    props.setLogPath("/tmp/logs");
+
+    SFClientConfig config = new SFClientConfig(props);
+    config.setConfigFilePath("/etc/snowflake/config.json");
+
+    assertEquals(props, config.getCommonProps());
+    assertEquals("/etc/snowflake/config.json", config.getConfigFilePath());
+  }
+
+  @Test
+  void testCommonPropsConstructorAndAccessors() {
+    SFClientConfig.CommonProps props = new SFClientConfig.CommonProps();
+    props.setLogLevel("DEBUG");
+    props.setLogPath("/var/logs/snowflake.log");
+
+    assertEquals("DEBUG", props.getLogLevel());
+    assertEquals("/var/logs/snowflake.log", props.getLogPath());
+  }
+
+  @Test
+  void testSFClientConfigEqualsAndHashCode() {
+    SFClientConfig.CommonProps props1 = new SFClientConfig.CommonProps();
+    props1.setLogLevel("INFO");
+    props1.setLogPath("/tmp");
+
+    SFClientConfig.CommonProps props2 = new SFClientConfig.CommonProps();
+    props2.setLogLevel("INFO");
+    props2.setLogPath("/tmp");
+    SFClientConfig config1 = new SFClientConfig(props1);
+    SFClientConfig config2 = new SFClientConfig(props2);
+
+    assertEquals(config1, config2);
+    assertEquals(config1.hashCode(), config2.hashCode());
+
+    // Negative test
+    props2.setLogLevel("DEBUG");
+    assertNotEquals(config1, new SFClientConfig(props2));
+  }
+
+  @Test
+  void testCommonPropsEqualsAndHashCode() {
+    SFClientConfig.CommonProps props1 = new SFClientConfig.CommonProps();
+    props1.setLogLevel("WARN");
+    props1.setLogPath("/opt/logs");
+    SFClientConfig.CommonProps props2 = new SFClientConfig.CommonProps();
+    props2.setLogLevel("WARN");
+    props2.setLogPath("/opt/logs");
+
+    assertEquals(props1, props2);
+    assertEquals(props1.hashCode(), props2.hashCode());
+
+    // Negative test
+    props2.setLogLevel("ERROR");
+    assertNotEquals(props1, props2);
+  }
 }

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

@@ -0,0 +1,55 @@
+package net.snowflake.client.core;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+class QueryContextEntryDTOTest {
+
+  @Mock private OpaqueContextDTO mockContext;
+
+  @BeforeEach
+  void setUp() {
+    MockitoAnnotations.openMocks(this);
+  }
+
+  @Test
+  void testDefaultConstructor() {
+    QueryContextEntryDTO entry = new QueryContextEntryDTO();
+    assertNotNull(entry);
+    assertEquals(0, entry.getId());
+    assertEquals(0, entry.getTimestamp());
+    assertEquals(0, entry.getPriority());
+    assertNull(entry.getContext());
+  }
+
+  @Test
+  void testParameterizedConstructor() {
+    QueryContextEntryDTO entry = new QueryContextEntryDTO(1L, 100L, 10L, mockContext);
+
+    assertEquals(1L, entry.getId());
+    assertEquals(100L, entry.getTimestamp());
+    assertEquals(10L, entry.getPriority());
+    assertEquals(mockContext, entry.getContext());
+  }
+
+  @Test
+  void testSettersAndGetters() {
+    QueryContextEntryDTO entry = new QueryContextEntryDTO();
+
+    entry.setId(2L);
+    entry.setTimestamp(200L);
+    entry.setPriority(20L);
+    entry.setContext(mockContext);
+
+    assertEquals(2L, entry.getId());
+    assertEquals(200L, entry.getTimestamp());
+    assertEquals(20L, entry.getPriority());
+    assertEquals(mockContext, entry.getContext());
+  }
+}

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

@@ -1,6 +1,7 @@
 package net.snowflake.client.core;
 
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.fail;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -14,6 +15,7 @@
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.net.SocketTimeoutException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
@@ -166,6 +168,25 @@ public void testSessionUtilExternalBrowser() throws Throwable {
       sub.authenticate();
       MatcherAssert.assertThat(
           "", sub.getToken(), equalTo(FakeSessionUtilExternalBrowser.MOCK_SAML_TOKEN));
+
+      sub = FakeSessionUtilExternalBrowser.createInstance(loginInput, false);
+      Mockito.when(loginInput.getDisableConsoleLogin()).thenReturn(false);
+      sub.authenticate();
+      MatcherAssert.assertThat(
+          "", sub.getToken(), equalTo(FakeSessionUtilExternalBrowser.MOCK_SAML_TOKEN));
+
+      sub = FakeSessionUtilExternalBrowser.createInstance(loginInput, false);
+      Mockito.when(loginInput.getDisableConsoleLogin())
+          .thenAnswer(
+              invocation -> {
+                throw new SocketTimeoutException("Test exception");
+              });
+      try {
+        sub.authenticate();
+        fail("should have failed with an exception.");
+      } catch (SFException ex) {
+        assertTrue(ex.getMessage().contains("External browser authentication failed"));
+      }
     }
   }
 
@@ -286,4 +307,43 @@ public void testExternalBrowserTimeout() throws Exception {
             });
     assertTrue(e.getMessage().contains("External browser authentication failed"));
   }
+
+  // @Test
+  // public void testSessionUtilExternalBrowserWithConsoleLogin() throws Throwable {
+  //  SFLoginInput loginInput = mock(SFLoginInput.class);
+  //  when(loginInput.getServerUrl()).thenReturn("https://testaccount.snowflakecomputing.com/");
+  //  when(loginInput.getAuthenticator())
+  //      .thenReturn(ClientAuthnDTO.AuthenticatorType.EXTERNALBROWSER.name());
+  //  when(loginInput.getAccountName()).thenReturn("testaccount");
+  //  when(loginInput.getUserName()).thenReturn("testuser");
+  //  when(loginInput.getDisableConsoleLogin()).thenReturn(false);
+  //
+  //  try (MockedStatic<HttpUtil> mockedHttpUtil = mockStatic(HttpUtil.class)) {
+  //    mockedHttpUtil
+  //        .when(
+  //            () ->
+  //                HttpUtil.executeGeneralRequest(
+  //                    Mockito.any(HttpRequestBase.class),
+  //                    Mockito.anyInt(),
+  //                    Mockito.anyInt(),
+  //                    Mockito.anyInt(),
+  //                    Mockito.anyInt(),
+  //                    Mockito.nullable(HttpClientSettingsKey.class)))
+  //        .thenReturn(
+  //            "{\"success\":\"true\",\"data\":{\"proofKey\":\""
+  //                + MOCK_PROOF_KEY
+  //                + "\","
+  //                + " \"ssoUrl\":\""
+  //                + MOCK_SSO_URL
+  //                + "\"}}");
+  //
+  //    SessionUtilExternalBrowser sub = FakeSessionUtilExternalBrowser.createInstance(loginInput);
+  //    sub.authenticate();
+  //    assertThat("", sub.getToken(), equalTo(FakeSessionUtilExternalBrowser.MOCK_SAML_TOKEN));
+  //
+  //    sub = FakeSessionUtilExternalBrowser.createInstance(loginInput, true);
+  //    sub.authenticate();
+  //    assertThat("", sub.getToken(), equalTo(FakeSessionUtilExternalBrowser.MOCK_SAML_TOKEN));
+  //  }
+  // }
 }

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

@@ -1,9 +1,11 @@
 package net.snowflake.client.core;
 
+import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.io.UnsupportedEncodingException;
 import org.junit.jupiter.api.Test;
 
 public class URLUtilTest {
@@ -27,4 +29,31 @@ public void testEncodeURL() throws Exception {
     assertEquals(URLUtil.urlEncode("Hello @World"), "Hello+%40World");
     assertEquals(URLUtil.urlEncode("Test//String"), "Test%2F%2FString");
   }
+
+  @Test
+  void testIsValidURL_InvalidCases() {
+    assertFalse(URLUtil.isValidURL("htp://invalid-url"));
+    assertFalse(URLUtil.isValidURL("://missing-protocol.com"));
+    assertFalse(URLUtil.isValidURL("https:/missing-slash.com"));
+    assertFalse(URLUtil.isValidURL("https://"));
+    assertFalse(URLUtil.isValidURL(""));
+    assertFalse(URLUtil.isValidURL(null));
+  }
+
+  @Test
+  void testUrlEncode_ValidString() throws UnsupportedEncodingException {
+    String input = "hello world!";
+    String expected = "hello+world%21"; // URLEncoder replaces spaces with '+'
+    assertEquals(expected, URLUtil.urlEncode(input));
+  }
+
+  @Test
+  void testUrlEncode_EmptyString() throws UnsupportedEncodingException {
+    assertEquals("", URLUtil.urlEncode(""));
+  }
+
+  @Test
+  void testUrlEncode_NullString() {
+    assertThrows(NullPointerException.class, () -> URLUtil.urlEncode(null));
+  }
 }

src/test/java/net/snowflake/client/core/auth/oauth/RandomStateProviderTest.java

@@ -0,0 +1,35 @@
+package net.snowflake.client.core.auth.oauth;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class RandomStateProviderTest {
+
+  private RandomStateProvider randomStateProvider;
+
+  @BeforeEach
+  public void setUp() {
+    // Initialize the RandomStateProvider before each test
+    randomStateProvider = new RandomStateProvider();
+  }
+
+  @Test
+  public void testGetState_ShouldReturnNonNullState() {
+    // Call getState() and verify that it returns a non-null value
+    String state = randomStateProvider.getState();
+    assertNotNull(state, "State should not be null");
+  }
+
+  @Test
+  public void testGetState_ShouldReturnUniqueValues() {
+    // Ensure that the state is random and different each time
+    String state1 = randomStateProvider.getState();
+    String state2 = randomStateProvider.getState();
+
+    // Assert that the two generated states are different
+    assertNotEquals(state1, state2, "State should be different on subsequent calls");
+  }
+}

src/test/java/net/snowflake/client/core/auth/oauth/TokenResponseDTOTest.java

@@ -0,0 +1,58 @@
+package net.snowflake.client.core.auth.oauth;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+
+public class TokenResponseDTOTest {
+
+  private static final String JSON_SAMPLE =
+      "{"
+          + "\"access_token\":\"abc123\","
+          + "\"refresh_token\":\"refresh123\","
+          + "\"token_type\":\"bearer\","
+          + "\"scope\":\"read write\","
+          + "\"username\":\"testUser\","
+          + "\"idp_initiated\":true,"
+          + "\"expires_in\":3600,"
+          + "\"refresh_token_expires_in\":7200"
+          + "}";
+
+  @Test
+  public void testConstructorAndGetters() {
+    TokenResponseDTO tokenResponseDTO =
+        new TokenResponseDTO(
+            "abc123", "refresh123", "bearer", "read write", "testUser", true, 3600, 7200);
+    // Assert that the constructor has correctly initialized the object
+    assertEquals("abc123", tokenResponseDTO.getAccessToken());
+    assertEquals("bearer", tokenResponseDTO.getTokenType());
+    assertEquals("refresh123", tokenResponseDTO.getRefreshToken());
+    assertEquals("read write", tokenResponseDTO.getScope());
+    assertEquals("testUser", tokenResponseDTO.getUsername());
+    assertTrue(tokenResponseDTO.isIdpInitiated());
+    assertEquals(3600, tokenResponseDTO.getExpiresIn());
+    assertEquals(7200, tokenResponseDTO.getRefreshTokenExpiresIn());
+  }
+
+  @Test
+  public void testJsonDeserialization() throws Exception {
+    // Create an ObjectMapper to convert JSON to TokenResponseDTO
+    ObjectMapper objectMapper = new ObjectMapper();
+
+    // Deserialize the JSON string into a TokenResponseDTO object
+    TokenResponseDTO deserializedTokenResponseDTO =
+        objectMapper.readValue(JSON_SAMPLE, TokenResponseDTO.class);
+
+    // Assert that the deserialized object matches the expected values
+    assertEquals("abc123", deserializedTokenResponseDTO.getAccessToken());
+    assertEquals("bearer", deserializedTokenResponseDTO.getTokenType());
+    assertEquals("refresh123", deserializedTokenResponseDTO.getRefreshToken());
+    assertEquals("read write", deserializedTokenResponseDTO.getScope());
+    assertEquals("testUser", deserializedTokenResponseDTO.getUsername());
+    assertTrue(deserializedTokenResponseDTO.isIdpInitiated());
+    assertEquals(3600, deserializedTokenResponseDTO.getExpiresIn());
+    assertEquals(7200, deserializedTokenResponseDTO.getRefreshTokenExpiresIn());
+  }
+}