Add additional unit tests for CSHttpConnection, covering form parameter handling, error setting, and URL parameter conversion, enhancing overall test coverage.

Author: harshithad0703

src/test/java/com/contentstack/sdk/TestCSHttpConnection.java

@@ -806,4 +806,205 @@ public void onRequestFail(ResponseType responseType, Error error) {}
         // Note: send() is not called here as it requires actual network infrastructure
         // The complete flow with send() is covered by integration tests
     }
+
+    // ========== ADDITIONAL BRANCH COVERAGE TESTS ==========
+
+    @Test
+    void testSetFormParamsGETWithNullResult() {
+        HashMap<String, Object> params = null;
+        
+        String result = connection.setFormParamsGET(params);
+        
+        assertNull(result);
+    }
+
+    @Test
+    void testSetFormParamsGETWithEmptyParamsReturnsNull() {
+        HashMap<String, Object> params = new HashMap<>();
+        
+        String result = connection.setFormParamsGET(params);
+        
+        assertNull(result);
+    }
+
+    @Test
+    void testSetFormParamsGETWithNonQueryNonEntryController() {
+        connection.setInfo("ASSET");
+        
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("key1", "value1");
+        params.put("key2", "value2");
+        
+        String result = connection.setFormParamsGET(params);
+        
+        assertNotNull(result);
+        assertTrue(result.contains("key1=value1"));
+        assertTrue(result.contains("key2=value2"));
+    }
+
+    @Test
+    void testSetFormParamsGETWithMultipleParams() {
+        connection.setInfo("OTHER");
+        
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("param1", "value1");
+        params.put("param2", "value2");
+        params.put("param3", "value3");
+        
+        String result = connection.setFormParamsGET(params);
+        
+        assertNotNull(result);
+        assertTrue(result.startsWith("?"));
+        assertTrue(result.contains("param1=value1"));
+        assertTrue(result.contains("&"));
+    }
+
+    @Test
+    void testGetParamsExceptionHandling() throws Exception {
+        connection.setInfo("QUERY");
+        
+        // Create a params map with a value that will cause encoding issues
+        HashMap<String, Object> params = new HashMap<>();
+        
+        // Add a mock object that will cause ClassCastException when treated as JSONObject
+        params.put("query", new Object() {
+            @Override
+            public String toString() {
+                return "{invalid}";
+            }
+        });
+        
+        Method getParamsMethod = CSHttpConnection.class.getDeclaredMethod("getParams", HashMap.class);
+        getParamsMethod.setAccessible(true);
+        
+        // This should handle the exception and log it, returning a partial URL
+        String result = (String) getParamsMethod.invoke(connection, params);
+        
+        assertNotNull(result);
+        // The method should continue despite the exception
+        assertTrue(result.startsWith("?"));
+    }
+
+    @Test
+    void testSendWithNullParams() {
+        connection.setInfo("QUERY");
+        connection.setFormParams(null);
+        
+        // Verify send can be called with null params without throwing
+        // Note: This will fail at network call, but that's expected in unit test
+        assertDoesNotThrow(() -> {
+            try {
+                // Setup minimal required fields
+                LinkedHashMap<String, Object> headers = new LinkedHashMap<>();
+                headers.put("api_key", "test");
+                connection.setHeaders(headers);
+                
+                Stack stack = Contentstack.stack("test", "test", "test");
+                connection.setConfig(stack.config);
+                connection.setAPIService(stack.service);
+                connection.setStack(stack);
+                
+                // This will fail at network level, but params handling is tested
+                connection.send();
+            } catch (Exception e) {
+                // Expected - network call will fail in unit test
+            }
+        });
+    }
+
+    @Test
+    void testSendWithEmptyParams() {
+        connection.setInfo("QUERY");
+        connection.setFormParams(new HashMap<>());
+        
+        assertDoesNotThrow(() -> {
+            try {
+                LinkedHashMap<String, Object> headers = new LinkedHashMap<>();
+                headers.put("api_key", "test");
+                connection.setHeaders(headers);
+                
+                Stack stack = Contentstack.stack("test", "test", "test");
+                connection.setConfig(stack.config);
+                connection.setAPIService(stack.service);
+                connection.setStack(stack);
+                
+                connection.send();
+            } catch (Exception e) {
+                // Expected
+            }
+        });
+    }
+
+    @Test
+    void testConvertUrlParamWithSingleElement() throws Exception {
+        Method convertUrlParamMethod = CSHttpConnection.class.getDeclaredMethod("convertUrlParam", 
+            String.class, Object.class, String.class);
+        convertUrlParamMethod.setAccessible(true);
+        
+        JSONArray array = new JSONArray();
+        array.put("single_value");
+        
+        String result = (String) convertUrlParamMethod.invoke(connection, "?", array, "test_key");
+        
+        assertNotNull(result);
+        assertTrue(result.contains("test_key=single_value"));
+    }
+
+    @Test
+    void testCreateOrderedJSONObjectWithMultipleEntries() throws Exception {
+        Method createOrderedMethod = CSHttpConnection.class.getDeclaredMethod("createOrderedJSONObject", Map.class);
+        createOrderedMethod.setAccessible(true);
+        
+        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+        map.put("key1", "value1");
+        map.put("key2", 123);
+        map.put("key3", true);
+        map.put("key4", "value4");
+        
+        JSONObject result = (JSONObject) createOrderedMethod.invoke(connection, map);
+        
+        assertNotNull(result);
+        assertEquals("value1", result.get("key1"));
+        assertEquals(123, result.get("key2"));
+        assertEquals(true, result.get("key3"));
+        assertEquals("value4", result.get("key4"));
+        assertEquals(4, result.length());
+    }
+
+    @Test
+    void testSetErrorWithEmptyString() {
+        MockIRequestModelHTTP csConnectionRequest = new MockIRequestModelHTTP();
+        CSHttpConnection conn = new CSHttpConnection("https://test.com", csConnectionRequest);
+        
+        conn.setError("");
+        
+        assertNotNull(csConnectionRequest.error);
+        assertTrue(csConnectionRequest.error.has("error_message"));
+        String errorMsg = csConnectionRequest.error.getString("error_message");
+        assertEquals("Unexpected error: No response received from server.", errorMsg);
+    }
+
+    @Test
+    void testSetErrorWithWhitespaceOnly() {
+        MockIRequestModelHTTP csConnectionRequest = new MockIRequestModelHTTP();
+        CSHttpConnection conn = new CSHttpConnection("https://test.com", csConnectionRequest);
+        
+        conn.setError("   ");
+        
+        assertNotNull(csConnectionRequest.error);
+        assertTrue(csConnectionRequest.error.has("error_message"));
+    }
+
+    @Test
+    void testSetErrorWithValidJSONButMissingAllFields() {
+        MockIRequestModelHTTP csConnectionRequest = new MockIRequestModelHTTP();
+        CSHttpConnection conn = new CSHttpConnection("https://test.com", csConnectionRequest);
+        
+        conn.setError("{\"some_field\": \"some_value\"}");
+        
+        assertNotNull(csConnectionRequest.error);
+        assertEquals("An unknown error occurred.", csConnectionRequest.error.getString("error_message"));
+        assertEquals("0", csConnectionRequest.error.getString("error_code"));
+        assertEquals("No additional error details available.", csConnectionRequest.error.getString("errors"));
+    }
 }