Enable core library desugaring in build.gradle and remove redundant exception handling tests in TestAssetLibraryAdvanced. Enhance TestClearCache with new tests for cache file management, ensuring proper deletion of old files and retention of recent files, while handling invalid JSON gracefully.

harshithad0703 · harshithad0703 · commit e0f9123214a0 · 2025-11-19T14:34:36.000+05:30
diff --git a/contentstack/build.gradle b/contentstack/build.gradle
@@ -17,6 +17,7 @@ android {
     // SDK compiles to Java 17 for JaCoCo compatibility
     // But can be built with Java 21 - tests use Java 17 toolchain
     compileOptions {
+        coreLibraryDesugaringEnabled true
         sourceCompatibility JavaVersion.VERSION_17
         targetCompatibility JavaVersion.VERSION_17
     }
diff --git a/contentstack/src/test/java/com/contentstack/sdk/TestAssetLibraryAdvanced.java b/contentstack/src/test/java/com/contentstack/sdk/TestAssetLibraryAdvanced.java
@@ -2122,68 +2122,6 @@ public void onCompletion(ResponseType responseType, List<Asset> assets, Error er
         }
     }
 
-    @Test
-    public void testExceptionHandlingInIncludeCountWithMockedJSONObject() {
-        try {
-            // Create a spy of JSONObject that throws exception
-            JSONObject mockUrlQueries = mock(JSONObject.class);
-            when(mockUrlQueries.put(anyString(), any())).thenThrow(new JSONException("Mock exception"));
-            
-            // Inject the mock via reflection
-            java.lang.reflect.Field urlQueriesField = AssetLibrary.class.getDeclaredField("urlQueries");
-            urlQueriesField.setAccessible(true);
-            Object originalUrlQueries = urlQueriesField.get(assetLibrary);
-            urlQueriesField.set(assetLibrary, mockUrlQueries);
-            
-            try {
-                // This should trigger the exception catch block in includeCount()
-                assetLibrary.includeCount();
-                
-                // Verify the exception path was executed (method should not throw)
-                assertTrue(true);
-                
-            } finally {
-                // Restore original value
-                urlQueriesField.set(assetLibrary, originalUrlQueries);
-            }
-            
-        } catch (Exception e) {
-            // The exception should be caught internally by includeCount
-            fail("Exception should be caught internally: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testExceptionHandlingInIncludeRelativeUrlWithMockedJSONObject() {
-        try {
-            // Create a mock JSONObject that throws exception
-            JSONObject mockUrlQueries = mock(JSONObject.class);
-            when(mockUrlQueries.put(anyString(), any())).thenThrow(new JSONException("Mock exception"));
-            
-            // Inject the mock via reflection
-            java.lang.reflect.Field urlQueriesField = AssetLibrary.class.getDeclaredField("urlQueries");
-            urlQueriesField.setAccessible(true);
-            Object originalUrlQueries = urlQueriesField.get(assetLibrary);
-            urlQueriesField.set(assetLibrary, mockUrlQueries);
-            
-            try {
-                // This should trigger the exception catch block in includeRelativeUrl()
-                assetLibrary.includeRelativeUrl();
-                
-                // Verify the exception path was executed
-                assertTrue(true);
-                
-            } finally {
-                // Restore original value
-                urlQueriesField.set(assetLibrary, originalUrlQueries);
-            }
-            
-        } catch (Exception e) {
-            // The exception should be caught internally
-            fail("Exception should be caught internally: " + e.getMessage());
-        }
-    }
-
     @Test
     public void testExceptionHandlingInIncludeFallbackWithMockedJSONObject() {
         try {
@@ -2216,74 +2154,6 @@ public void testExceptionHandlingInIncludeFallbackWithMockedJSONObject() {
         }
     }
 
-    @Test
-    public void testExceptionHandlingInIncludeMetadataWithMockedJSONObject() {
-        try {
-            // Create a mock JSONObject that throws JSONException
-            JSONObject mockUrlQueries = mock(JSONObject.class);
-            when(mockUrlQueries.put(anyString(), any())).thenThrow(new JSONException("Mock exception"));
-            
-            // Inject the mock via reflection
-            java.lang.reflect.Field urlQueriesField = AssetLibrary.class.getDeclaredField("urlQueries");
-            urlQueriesField.setAccessible(true);
-            Object originalUrlQueries = urlQueriesField.get(assetLibrary);
-            urlQueriesField.set(assetLibrary, mockUrlQueries);
-            
-            try {
-                // This should trigger the JSONException catch block in includeMetadata()
-                assetLibrary.includeMetadata();
-                
-                // Verify the exception path was executed
-                assertTrue(true);
-                
-            } finally {
-                // Restore original value
-                urlQueriesField.set(assetLibrary, originalUrlQueries);
-            }
-            
-        } catch (Exception e) {
-            // The exception should be caught internally by includeMetadata
-            fail("Exception should be caught internally: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testExceptionHandlingInWhereWithMockedJSONObject() {
-        try {
-            // Create a mock JSONObject that throws JSONException
-            JSONObject mockUrlQueries = mock(JSONObject.class);
-            JSONObject mockQueryParams = mock(JSONObject.class);
-            when(mockQueryParams.put(anyString(), any())).thenThrow(new JSONException("Mock exception"));
-            when(mockUrlQueries.put(eq("query"), any(JSONObject.class))).thenReturn(mockUrlQueries);
-            
-            // We need to mock the constructor behavior by replacing urlQueries
-            java.lang.reflect.Field urlQueriesField = AssetLibrary.class.getDeclaredField("urlQueries");
-            urlQueriesField.setAccessible(true);
-            Object originalUrlQueries = urlQueriesField.get(assetLibrary);
-            
-            // Create a real JSONObject but configure it to fail during where()
-            JSONObject spyUrlQueries = spy(new JSONObject());
-            doThrow(new JSONException("Mock exception")).when(spyUrlQueries).put(eq("query"), any(JSONObject.class));
-            urlQueriesField.set(assetLibrary, spyUrlQueries);
-            
-            try {
-                // This should trigger the JSONException catch block in where()
-                assetLibrary.where("test_key", "test_value");
-                
-                // Verify the exception path was executed
-                assertTrue(true);
-                
-            } finally {
-                // Restore original value
-                urlQueriesField.set(assetLibrary, originalUrlQueries);
-            }
-            
-        } catch (Exception e) {
-            // The exception should be caught internally by where
-            fail("Exception should be caught internally: " + e.getMessage());
-        }
-    }
-
     @Test
     public void testExceptionHandlingInFetchAllCatchBlock() {
         try {
diff --git a/contentstack/src/test/java/com/contentstack/sdk/TestClearCache.java b/contentstack/src/test/java/com/contentstack/sdk/TestClearCache.java
@@ -1,101 +1,140 @@
 package com.contentstack.sdk;
 
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
 import android.content.Context;
 import android.content.Intent;
 
 import org.json.JSONObject;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
 
 import java.io.File;
 import java.io.FileWriter;
-import java.util.Calendar;
-import java.util.TimeZone;
 import java.util.concurrent.TimeUnit;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
+@RunWith(RobolectricTestRunner.class)
 public class TestClearCache {
 
-    private File createTempDir() {
-        File dir = new File(System.getProperty("java.io.tmpdir"),
-                "ContentstackCacheTest_" + System.nanoTime());
-        //noinspection ResultOfMethodCallIgnored
-        dir.mkdirs();
-        return dir;
-    }
+    private Context context;
+    private File cacheDir;
+
+    @Before
+    public void setUp() {
+        context = RuntimeEnvironment.getApplication();
 
-    private File writeCacheFile(File dir, String name, long timestampMillis) throws Exception {
-        File file = new File(dir, name);
-        JSONObject json = new JSONObject();
-        json.put("timestamp", String.valueOf(timestampMillis));
-        try (FileWriter writer = new FileWriter(file)) {
-            writer.write(json.toString());
+        // This will be something like /data/data/.../app_ContentstackCache-test
+        cacheDir = context.getDir("ContentstackCache", 0);
+
+        // Clean it before each test
+        File[] files = cacheDir.listFiles();
+        if (files != null) {
+            for (File f : files) {
+                // Best-effort cleanup
+                f.delete();
+            }
         }
-        return file;
     }
 
+    private File createJsonCacheFile(String name, long timestampMillis) throws Exception {
+        File f = new File(cacheDir, name);
+        JSONObject obj = new JSONObject();
+        obj.put("timestamp", String.valueOf(timestampMillis));
+        FileWriter writer = new FileWriter(f);
+        writer.write(obj.toString());
+        writer.flush();
+        writer.close();
+        return f;
+    }
+
+    private File createPlainFile(String name) throws Exception {
+        File f = new File(cacheDir, name);
+        FileWriter writer = new FileWriter(f);
+        writer.write("dummy");
+        writer.flush();
+        writer.close();
+        return f;
+    }
+
+    private long now() {
+        return System.currentTimeMillis();
+    }
+
+    // ----------------------------------------------------
+    // 1. Old file (>=24h) should be deleted
+    // ----------------------------------------------------
     @Test
-    public void testOnReceive_deletesOldFilesAndKeepsRecent() throws Exception {
-        // Mock Context
-        Context context = mock(Context.class);
+    public void testOnReceive_deletesOldFile() throws Exception {
+        long twentyFiveHoursAgo = now() - TimeUnit.HOURS.toMillis(25);
+
+        File oldFile = createJsonCacheFile("old_response.json", twentyFiveHoursAgo);
 
-        // Use a temp directory to simulate ContentstackCache
-        File cacheDir = createTempDir();
-        when(context.getDir("ContentstackCache", 0)).thenReturn(cacheDir);
+        assertTrue("Old file should exist before onReceive", oldFile.exists());
 
-        // current time (UTC aligned like ClearCache)
-        Calendar cal = Calendar.getInstance();
-        cal.setTimeZone(TimeZone.getTimeZone("UTC"));
-        long nowMillis = cal.getTimeInMillis();
+        ClearCache clearCache = new ClearCache();
+        clearCache.onReceive(context, new Intent("com.contentstack.sdk.CLEAR_CACHE"));
 
-        long twentyFiveHoursAgo = nowMillis - TimeUnit.HOURS.toMillis(25);
-        long oneHourAgo = nowMillis - TimeUnit.HOURS.toMillis(1);
+        assertFalse("Old file should be deleted", oldFile.exists());
+    }
 
-        // old file: should be deleted
-        File oldFile = writeCacheFile(cacheDir, "old_response.json", twentyFiveHoursAgo);
+    // ----------------------------------------------------
+    // 2. Recent file (<24h) should NOT be deleted
+    // ----------------------------------------------------
+    @Test
+    public void testOnReceive_keepsRecentFile() throws Exception {
+        long oneHourAgo = now() - TimeUnit.HOURS.toMillis(1);
 
-        // recent file: should be kept
-        File recentFile = writeCacheFile(cacheDir, "recent_response.json", oneHourAgo);
+        File recentFile = createJsonCacheFile("recent_response.json", oneHourAgo);
 
-        // session and installation files: never deleted
-        File sessionFile = writeCacheFile(cacheDir, "Session", twentyFiveHoursAgo);
-        File installationFile = writeCacheFile(cacheDir, "Installation", twentyFiveHoursAgo);
+        assertTrue("Recent file should exist before onReceive", recentFile.exists());
 
         ClearCache clearCache = new ClearCache();
-        clearCache.onReceive(context, new Intent("test.intent.CLEAR_CACHE"));
+        clearCache.onReceive(context, new Intent("com.contentstack.sdk.CLEAR_CACHE"));
+
+        assertTrue("Recent file should NOT be deleted", recentFile.exists());
+    }
+
+    // ----------------------------------------------------
+    // 3. Session and Installation files are ignored
+    // ----------------------------------------------------
+    @Test
+    public void testOnReceive_ignoresSessionAndInstallationFiles() throws Exception {
+        // Even if they look old, code explicitly ignores them
+
+        long twentyFiveHoursAgo = now() - TimeUnit.HOURS.toMillis(25);
 
-        // Old file should be gone
-        assertFalse("Old cache file should be deleted", oldFile.exists());
+        File sessionFile = createJsonCacheFile("Session", twentyFiveHoursAgo);
+        File installationFile = createJsonCacheFile("Installation", twentyFiveHoursAgo);
 
-        // Recent file should still be there
-        assertTrue("Recent cache file should not be deleted", recentFile.exists());
+        assertTrue(sessionFile.exists());
+        assertTrue(installationFile.exists());
+
+        ClearCache clearCache = new ClearCache();
+        clearCache.onReceive(context, new Intent("com.contentstack.sdk.CLEAR_CACHE"));
 
-        // Session and Installation should not be deleted
+        // They should still exist because of the name-based skip condition
         assertTrue("Session file should not be deleted", sessionFile.exists());
         assertTrue("Installation file should not be deleted", installationFile.exists());
     }
 
+    // ----------------------------------------------------
+    // 4. File without valid JSON or timestamp should be ignored (no crash)
+    // ----------------------------------------------------
     @Test
-    public void testOnReceive_handlesEmptyDirectoryGracefully() {
-        Context context = mock(Context.class);
+    public void testOnReceive_invalidJsonOrNoTimestamp_doesNotCrashAndKeepsFile() throws Exception {
+        File invalidFile = createPlainFile("invalid.json");
 
-        File cacheDir = createTempDir();
-        when(context.getDir("ContentstackCache", 0)).thenReturn(cacheDir);
-
-        // Ensure directory is empty
-        File[] existing = cacheDir.listFiles();
-        if (existing != null) {
-            for (File f : existing) {
-                //noinspection ResultOfMethodCallIgnored
-                f.delete();
-            }
-        }
+        assertTrue(invalidFile.exists());
 
         ClearCache clearCache = new ClearCache();
-        clearCache.onReceive(context, new Intent("test.intent.CLEAR_CACHE"));
+        clearCache.onReceive(context, new Intent("com.contentstack.sdk.CLEAR_CACHE"));
 
-        // No crash is success; directory should still exist
-        assertTrue(cacheDir.exists());
+        // Since getJsonFromCacheFile likely returns null or throws handled internally,
+        // the file should not be deleted by our logic.
+        assertTrue("Invalid file should still exist", invalidFile.exists());
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ android {`
`17`	`17`	`// SDK compiles to Java 17 for JaCoCo compatibility`
`18`	`18`	`// But can be built with Java 21 - tests use Java 17 toolchain`
`19`	`19`	`compileOptions {`
	`20`	`+ coreLibraryDesugaringEnabled true`
`20`	`21`	`sourceCompatibility JavaVersion.VERSION_17`
`21`	`22`	`targetCompatibility JavaVersion.VERSION_17`
`22`	`23`	`}`