Add comprehensive unit tests for Query class, specifically for the greaterThanOrEqualTo method, covering various scenarios including null keys, existing keys, chaining, and different value types to enhance test coverage.

Author: harshithad0703

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

@@ -1518,4 +1518,188 @@ void testEmptyArrayValidation() {
         // Empty array should not create objectUidForExcept
         assertNull(query.objectUidForExcept);
     }
+
+    // ========== COMPREHENSIVE TESTS FOR greaterThanOrEqualTo ==========
+
+    @Test
+    void testGreaterThanOrEqualToWithNullKeyInQueryValueJSON() {
+        // Test the first branch: queryValueJSON.isNull(key) is true
+        // AND queryValue.length() == 0
+        query.queryValue = new JSONObject(); // Empty queryValue
+        query.queryValueJSON.put("price", JSONObject.NULL);
+        
+        Query result = query.greaterThanOrEqualTo("price", 50);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("price"));
+        assertNotEquals(JSONObject.NULL, query.queryValueJSON.get("price"));
+        
+        // Verify the $gte operator was added
+        JSONObject priceQuery = query.queryValueJSON.getJSONObject("price");
+        assertTrue(priceQuery.has("$gte"));
+        assertEquals(50, priceQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithNullKeyAndNonEmptyQueryValue() {
+        // Test the first branch: queryValueJSON.isNull(key) is true
+        // AND queryValue.length() > 0 (should reset queryValue)
+        query.queryValue = new JSONObject();
+        query.queryValue.put("existing_operator", "some_value"); // Make queryValue non-empty
+        query.queryValueJSON.put("rating", JSONObject.NULL);
+        
+        Query result = query.greaterThanOrEqualTo("rating", 4.5);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("rating"));
+        
+        // Verify the $gte operator was added
+        JSONObject ratingQuery = query.queryValueJSON.getJSONObject("rating");
+        assertTrue(ratingQuery.has("$gte"));
+        assertEquals(4.5, ratingQuery.get("$gte"));
+        // The queryValue should have been reset, so it shouldn't have the old key
+        assertFalse(ratingQuery.has("existing_operator"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithExistingKeyInQueryValueJSON() {
+        // Test the second branch: queryValueJSON.has(key) is true
+        // First set up queryValue with an existing operator
+        query.queryValue = new JSONObject();
+        query.queryValue.put("$lt", 100);
+        query.queryValueJSON.put("age", query.queryValue);
+        
+        Query result = query.greaterThanOrEqualTo("age", 18);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("age"));
+        
+        // Verify both operators exist in the same JSONObject
+        JSONObject ageQuery = query.queryValueJSON.getJSONObject("age");
+        assertTrue(ageQuery.has("$gte"));
+        assertEquals(18, ageQuery.get("$gte"));
+        // The previous operator should still be there since queryValue was reused
+        assertTrue(ageQuery.has("$lt"));
+        assertEquals(100, ageQuery.get("$lt"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithIntegerValue() {
+        Query result = query.greaterThanOrEqualTo("count", 100);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("count"));
+        
+        JSONObject countQuery = query.queryValueJSON.getJSONObject("count");
+        assertEquals(100, countQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithDoubleValue() {
+        Query result = query.greaterThanOrEqualTo("price", 99.99);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("price"));
+        
+        JSONObject priceQuery = query.queryValueJSON.getJSONObject("price");
+        assertEquals(99.99, priceQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithStringValue() {
+        Query result = query.greaterThanOrEqualTo("name", "Alice");
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("name"));
+        
+        JSONObject nameQuery = query.queryValueJSON.getJSONObject("name");
+        assertEquals("Alice", nameQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToChaining() {
+        Query result = query
+            .greaterThanOrEqualTo("min_price", 10)
+            .greaterThanOrEqualTo("min_rating", 3.0)
+            .greaterThanOrEqualTo("min_stock", 5);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("min_price"));
+        assertTrue(query.queryValueJSON.has("min_rating"));
+        assertTrue(query.queryValueJSON.has("min_stock"));
+        
+        assertEquals(10, query.queryValueJSON.getJSONObject("min_price").get("$gte"));
+        assertEquals(3.0, query.queryValueJSON.getJSONObject("min_rating").get("$gte"));
+        assertEquals(5, query.queryValueJSON.getJSONObject("min_stock").get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithZeroValue() {
+        Query result = query.greaterThanOrEqualTo("score", 0);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("score"));
+        
+        JSONObject scoreQuery = query.queryValueJSON.getJSONObject("score");
+        assertEquals(0, scoreQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithNegativeValue() {
+        Query result = query.greaterThanOrEqualTo("temperature", -10);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("temperature"));
+        
+        JSONObject tempQuery = query.queryValueJSON.getJSONObject("temperature");
+        assertEquals(-10, tempQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToReplacingExistingOperator() {
+        // Add an initial $gte operator
+        query.greaterThanOrEqualTo("age", 18);
+        
+        // Add another $gte operator on the same key - should update
+        Query result = query.greaterThanOrEqualTo("age", 21);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("age"));
+        
+        JSONObject ageQuery = query.queryValueJSON.getJSONObject("age");
+        // Should have the updated value
+        assertEquals(21, ageQuery.get("$gte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToCombinedWithOtherOperators() {
+        // Combine with lessThanOrEqualTo to create a range query
+        Query result = query
+            .greaterThanOrEqualTo("price", 10)
+            .lessThanOrEqualTo("price", 100);
+        
+        assertNotNull(result);
+        assertTrue(query.queryValueJSON.has("price"));
+        
+        JSONObject priceQuery = query.queryValueJSON.getJSONObject("price");
+        assertTrue(priceQuery.has("$gte"));
+        assertTrue(priceQuery.has("$lte"));
+        assertEquals(10, priceQuery.get("$gte"));
+        assertEquals(100, priceQuery.get("$lte"));
+    }
+
+    @Test
+    void testGreaterThanOrEqualToWithValidKeyFormat() {
+        // Test with various valid key formats
+        Query result1 = query.greaterThanOrEqualTo("simple_key", 10);
+        Query result2 = query.greaterThanOrEqualTo("nested.field", 20);
+        Query result3 = query.greaterThanOrEqualTo("key_with_123", 30);
+        
+        assertNotNull(result1);
+        assertNotNull(result2);
+        assertNotNull(result3);
+        assertTrue(query.queryValueJSON.has("simple_key"));
+        assertTrue(query.queryValueJSON.has("nested.field"));
+        assertTrue(query.queryValueJSON.has("key_with_123"));
+    }
 }

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

@@ -1,8 +1,10 @@
 package com.contentstack.sdk;
 
+import okhttp3.ResponseBody;
 import org.json.JSONObject;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import retrofit2.Call;
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;
@@ -537,5 +539,92 @@ void testQueryToStringContainsAllOperators() {
         // Verify it's valid JSON
         assertDoesNotThrow(() -> new JSONObject(queryString));
     }
+
+    // ========== TESTS FOR FIND METHOD ERROR HANDLING ==========
+    // Note: The find() method is network-dependent and requires actual API calls.
+    // Comprehensive error handling tests (IOException -> RuntimeException,
+    // HTTP error codes 400/401/404/500, error message/code/detail parsing)
+    // should be covered in integration tests (TaxonomyIT.java) where actual
+    // network responses can be tested with valid credentials.
+    //
+    // Without mocking framework, unit tests for find() are limited to:
+    // 1. Verifying makeRequest() returns a non-null Call object
+    // 2. Verifying the query is properly constructed before the call
+    //
+    // Full error path coverage requires integration testing with real API responses.
+
+    @Test
+    void testMakeRequestReturnsNonNullCall() {
+        taxonomy.in("taxonomies.color", Arrays.asList("red", "blue"))
+                .exists("taxonomies.size", true);
+        
+        Call<ResponseBody> call = taxonomy.makeRequest();
+        
+        assertNotNull(call, "makeRequest should return a non-null Call object");
+    }
+
+    @Test
+    void testQueryIsProperlyConstructedBeforeMakeRequest() {
+        taxonomy.in("taxonomies.color", Arrays.asList("red"))
+                .or(Arrays.asList(
+                        new JSONObject().put("taxonomies.size", "large"),
+                        new JSONObject().put("taxonomies.brand", "nike")
+                ))
+                .exists("taxonomies.stock", true);
+        
+        // Verify query contains all expected keys
+        assertTrue(taxonomy.query.has("taxonomies.color"));
+        assertTrue(taxonomy.query.has("$or"));
+        assertTrue(taxonomy.query.has("taxonomies.stock"));
+        
+        // Verify query is valid JSON
+        String queryString = taxonomy.query.toString();
+        assertDoesNotThrow(() -> new JSONObject(queryString));
+        
+        // Verify makeRequest can be called without error
+        assertDoesNotThrow(() -> taxonomy.makeRequest());
+    }
+
+    @Test
+    void testFindMethodSignatureAndCallbackInterface() {
+        // Verify TaxonomyCallback interface contract
+        final boolean[] callbackCalled = {false};
+        final JSONObject[] receivedResponse = new JSONObject[1];
+        final Error[] receivedError = new Error[1];
+        
+        TaxonomyCallback callback = new TaxonomyCallback() {
+            @Override
+            public void onResponse(JSONObject response, Error error) {
+                callbackCalled[0] = true;
+                receivedResponse[0] = response;
+                receivedError[0] = error;
+            }
+        };
+        
+        // Verify callback can be instantiated and methods are accessible
+        assertNotNull(callback);
+        
+        // Test callback with null error (success case)
+        callback.onResponse(new JSONObject().put("test", "data"), null);
+        assertTrue(callbackCalled[0]);
+        assertNotNull(receivedResponse[0]);
+        assertNull(receivedError[0]);
+        
+        // Reset and test with error (failure case)
+        callbackCalled[0] = false;
+        receivedResponse[0] = null;
+        receivedError[0] = null;
+        
+        Error testError = new Error();
+        testError.setErrorMessage("Test error");
+        testError.setErrorCode(400);
+        
+        callback.onResponse(null, testError);
+        assertTrue(callbackCalled[0]);
+        assertNull(receivedResponse[0]);
+        assertNotNull(receivedError[0]);
+        assertEquals("Test error", receivedError[0].getErrorMessage());
+        assertEquals(400, receivedError[0].getErrorCode());
+    }
 }