Clear media sets cache and media sets content cache for a given

categoryId and its authority

The current implementation erases the complete cache for both media sets
and media set content. It is fine for the MVP since we only have one
category at the moment but in case we add more in the future, this
should not be the behaviour.

Test: verified manually, fixed corresponding tests

Bug: 394050877

Flag: com.android.providers.media.flags.enable_photopicker_search
Change-Id: Idd8980c0e573376df8100b44102dcc01b5e8e992

8 files changed, 230 insertions, 29 deletions

diff --git a/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorker.java b/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorker.java
index 5991ae049..e847bd505 100644
--- a/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorker.java
+++ b/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorker.java
@@ -16,9 +16,13 @@
 
 package com.android.providers.media.photopicker.sync;
 
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_AUTHORITY;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_CATEGORY_ID;
 import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_SYNC_SOURCE;
 import static com.android.providers.media.photopicker.sync.SyncTrackerRegistry.markMediaSetsSyncAsComplete;
 
+import static java.util.Objects.requireNonNull;
+
 import android.content.Context;
 import android.database.sqlite.SQLiteDatabase;
 import android.util.Log;
@@ -33,9 +37,11 @@ import com.android.providers.media.photopicker.util.exceptions.RequestObsoleteEx
 import com.android.providers.media.photopicker.v2.sqlite.MediaInMediaSetsDatabaseUtil;
 import com.android.providers.media.photopicker.v2.sqlite.MediaSetsDatabaseUtil;
 
+import java.util.List;
+
 /**
- * This worker is responsible for cleaning up the cached media sets or media sets content based
- * on the type input reset parameter received
+ * This worker is responsible for cleaning up the cached media sets or media sets content for the
+ * given categoryId
  */
 public class MediaSetsResetWorker extends Worker {
     private static final String TAG = "MediaSetsResetWorker";
@@ -50,6 +56,8 @@ public class MediaSetsResetWorker extends Worker {
 
         final int syncSource = getInputData().getInt(SYNC_WORKER_INPUT_SYNC_SOURCE,
                 /* defaultValue */ -1);
+        final String categoryId = getInputData().getString(SYNC_WORKER_INPUT_CATEGORY_ID);
+        final String authority = getInputData().getString(SYNC_WORKER_INPUT_AUTHORITY);
 
         // Do not allow endless re-runs of this worker, if this isn't the original run,
         // just fail and wait until the next scheduled run.
@@ -58,18 +66,24 @@ public class MediaSetsResetWorker extends Worker {
             return ListenableWorker.Result.failure();
         }
 
-        boolean isMediaSetsTableDeleted = clearMediaSetsCache(syncSource);
-        boolean isMediaInMediaSetsTabledDeleted = clearMediaSetsContentCache();
+        boolean isMediaInMediaSetsCacheDeleted = clearMediaSetsContentCache(categoryId, authority);
+        boolean isMediaSetsCacheDeleted = clearMediaSetsCache(syncSource, categoryId, authority);
 
         // Both the tables were cleared. Mark the worker's run as success
-        if (isMediaSetsTableDeleted && isMediaInMediaSetsTabledDeleted) {
+        if (isMediaSetsCacheDeleted && isMediaInMediaSetsCacheDeleted) {
             return ListenableWorker.Result.success();
         }
 
         return ListenableWorker.Result.failure();
     }
 
-    private boolean clearMediaSetsCache(int syncSource) {
+    private boolean clearMediaSetsCache(int syncSource,
+                                        @NonNull String categoryId,
+                                        @NonNull String authority) {
+
+        requireNonNull(categoryId);
+        requireNonNull(authority);
+
         SQLiteDatabase database = getDatabase();
 
         try {
@@ -77,7 +91,7 @@ public class MediaSetsResetWorker extends Worker {
 
             database.beginTransaction();
 
-            MediaSetsDatabaseUtil.clearMediaSetsCache(database);
+            MediaSetsDatabaseUtil.clearMediaSetsCache(database, categoryId, authority);
 
             if (database.inTransaction()) {
                 database.setTransactionSuccessful();
@@ -97,7 +111,12 @@ public class MediaSetsResetWorker extends Worker {
         }
     }
 
-    private boolean clearMediaSetsContentCache() {
+    private boolean clearMediaSetsContentCache(
+            @NonNull String categoryId,
+            @NonNull String authority) {
+
+        requireNonNull(categoryId);
+        requireNonNull(authority);
 
         SQLiteDatabase database = getDatabase();
 
@@ -106,7 +125,10 @@ public class MediaSetsResetWorker extends Worker {
 
             database.beginTransaction();
 
-            MediaInMediaSetsDatabaseUtil.clearMediaInMediaSetsCache(database);
+            List<String> mediaSetPickerIds = MediaSetsDatabaseUtil
+                    .getMediaSetPickerIdsForGivenCategoryId(database, categoryId, authority);
+            MediaInMediaSetsDatabaseUtil.clearMediaInMediaSetsCache(
+                    database, mediaSetPickerIds);
 
             if (database.inTransaction()) {
                 database.setTransactionSuccessful();
diff --git a/src/com/android/providers/media/photopicker/sync/PickerSyncManager.java b/src/com/android/providers/media/photopicker/sync/PickerSyncManager.java
index 3c247a947..85cd059ac 100644
--- a/src/com/android/providers/media/photopicker/sync/PickerSyncManager.java
+++ b/src/com/android/providers/media/photopicker/sync/PickerSyncManager.java
@@ -650,9 +650,10 @@ public class PickerSyncManager {
 
     /**
      * Creates OneTimeWork request for syncing media sets with the given provider.
-     * The existing media sets cache and the media sets content cache is cleared before a new media
-     * sets sync is triggered to ensure accuracy of the media sets metadata stored in the database.
-     * The reset cache and sync requests are chained to ensure correctness of the entire operation.
+     * The existing media sets cache and the media sets content cache for the given categoryId
+     * is cleared before a new media sets sync is triggered to ensure accuracy of the media sets
+     * metadata stored in the database. The reset cache and sync requests are chained to ensure
+     * correctness of the entire operation.
      * @param requestParams The MediaSetsSyncRequestsParams object containing all input parameters
      *                      for creating a sync request
      * @param syncSource Indicates whether the sync is required with the local provider or
@@ -675,15 +676,18 @@ public class PickerSyncManager {
                 buildOneTimeWorkerRequest(MediaSetsSyncWorker.class, syncRequestInputData);
 
         // Create media sets reset request. MediaSets sync are non-resumable.
-        // It's fine to delete the entire cache before a new set is triggered.
-        // The media sets content cache is also completely cleared before we start syncing
-        // any particular media set for its content.
+        // It's fine to delete the entire cache before a new set is triggered for the given
+        // categoryId.
+        // The media sets content cache for media sets belonging to the given categoryId
+        // is also cleared before we start syncing any particular media set for its content.
         // These tables are cleared once per picker session before the media sets sync for this
         // session is triggered. This ensures that the data read from the cache in every session
         // is always in sync with the cloud provider.
-        final Data resetRequestInputData = new Data(Map.of(
-                SYNC_WORKER_INPUT_SYNC_SOURCE, syncSource
-        ));
+        final Map<String, Object> resetRequestInputMap = new HashMap<>();
+        resetRequestInputMap.put(SYNC_WORKER_INPUT_SYNC_SOURCE, syncSource);
+        resetRequestInputMap.put(SYNC_WORKER_INPUT_CATEGORY_ID, requestParams.getCategoryId());
+        resetRequestInputMap.put(SYNC_WORKER_INPUT_AUTHORITY, requestParams.getAuthority());
+        final Data resetRequestInputData = new Data(resetRequestInputMap);
         final OneTimeWorkRequest resetRequest =
                 buildOneTimeWorkerRequest(MediaSetsResetWorker.class, resetRequestInputData);
 
diff --git a/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtil.java b/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtil.java
index 28c3ebbf4..e6e729718 100644
--- a/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtil.java
+++ b/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtil.java
@@ -341,19 +341,41 @@ public class MediaInMediaSetsDatabaseUtil {
     /**
      * Deletes all the rows from the MediaInMediaSets table
      */
-    public static void clearMediaInMediaSetsCache(@NonNull SQLiteDatabase database) {
+    public static void clearMediaInMediaSetsCache(
+            @NonNull SQLiteDatabase database, @NonNull List<String> mediaSetPickerIds) {
 
         requireNonNull(database);
+        requireNonNull(mediaSetPickerIds);
+
+        if (mediaSetPickerIds.isEmpty()) {
+            return;
+        }
+
+        String whereClause =
+                PickerSQLConstants.MediaInMediaSetsTableColumns.MEDIA_SETS_PICKER_ID.getColumnName()
+                        + " IN (" + generatePlaceholders(mediaSetPickerIds.size()) + ")";
+        String[] whereArgs = mediaSetPickerIds.toArray(new String[0]);
 
         try {
             int deletedRows = database.delete(
                     PickerSQLConstants.Table.MEDIA_IN_MEDIA_SETS.name(),
-                    /*whereClause*/ null,
-                    /*whereArgs*/ null);
+                    whereClause,
+                    whereArgs);
 
             Log.d(TAG, "Deleted " + deletedRows + " rows from the media in media sets table");
         } catch (Exception e) {
             Log.d(TAG, "Couldn't clear the media in media sets table due to " + e);
         }
     }
+
+    private static String generatePlaceholders(int size) {
+        StringBuilder placeholders = new StringBuilder();
+        for (int i = 0; i < size; i++) {
+            placeholders.append("?");
+            if (i < size - 1) {
+                placeholders.append(",");
+            }
+        }
+        return placeholders.toString();
+    }
 }
diff --git a/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtil.java b/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtil.java
index f71b9d4ac..6fc045561 100644
--- a/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtil.java
+++ b/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtil.java
@@ -289,15 +289,25 @@ public class MediaSetsDatabaseUtil {
     /**
      * Deletes all the rows from the MediaSets table
      */
-    public static void clearMediaSetsCache(@NonNull SQLiteDatabase database) {
+    public static void clearMediaSetsCache(
+            @NonNull SQLiteDatabase database,
+            @NonNull String categoryId,
+            @NonNull String authority) {
 
         requireNonNull(database);
+        requireNonNull(categoryId);
+        requireNonNull(authority);
 
+        String whereClause = PickerSQLConstants.MediaSetsTableColumns.CATEGORY_ID.getColumnName()
+                + " = ? AND "
+                + PickerSQLConstants.MediaSetsTableColumns.MEDIA_SET_AUTHORITY.getColumnName()
+                + " = ?";
+        String[] whereArgs = new String[] { categoryId, authority };
         try {
             int deletedRows = database.delete(
                     PickerSQLConstants.Table.MEDIA_SETS.name(),
-                    /*whereClause*/ null,
-                    /*whereClauseArgs*/ null);
+                    whereClause,
+                    whereArgs);
 
             Log.d(TAG, "Deleted " + deletedRows + " rows from the media sets table.");
         } catch (Exception exception) {
@@ -305,6 +315,52 @@ public class MediaSetsDatabaseUtil {
         }
     }
 
+    /**
+     * Fetches the generated database ids, also called media_set_picker_id for the given
+     * categoryId
+     */
+    public static List<String> getMediaSetPickerIdsForGivenCategoryId(
+            @NonNull SQLiteDatabase database,
+            @NonNull String categoryId,
+            @NonNull String authority) {
+
+        requireNonNull(database);
+        requireNonNull(categoryId);
+        requireNonNull(authority);
+
+        List<String> mediaSetPickerIds = new ArrayList<>();
+
+        final List<String> projection = List.of(
+                PickerSQLConstants.MediaSetsTableColumns.PICKER_ID
+                        .getColumnName());
+        final SelectSQLiteQueryBuilder queryBuilder = new SelectSQLiteQueryBuilder(database)
+                .setTables(PickerSQLConstants.Table.MEDIA_SETS.name())
+                .setProjection(projection);
+        queryBuilder.appendWhereStandalone(
+                String.format(Locale.ROOT, " %s = '%s' ",
+                        PickerSQLConstants.MediaSetsTableColumns.CATEGORY_ID.getColumnName(),
+                        categoryId)
+        );
+        queryBuilder.appendWhereStandalone(
+                String.format(Locale.ROOT, " %s = '%s' ",
+                        PickerSQLConstants.MediaSetsTableColumns.MEDIA_SET_AUTHORITY
+                                .getColumnName(),
+                        authority)
+        );
+
+        try (Cursor cursor = database.rawQuery(queryBuilder.buildQuery(), /*selectionArgs*/ null)) {
+            if (cursor.moveToFirst()) {
+                do {
+                    int pickerIdIndex = cursor.getColumnIndex(
+                            PickerSQLConstants.MediaSetsTableColumns.PICKER_ID.getColumnName());
+                    String pickerId = cursor.getString(pickerIdIndex);
+                    mediaSetPickerIds.add(pickerId);
+                } while (cursor.moveToNext());
+            }
+        }
+        return mediaSetPickerIds;
+    }
+
     private static List<ContentValues> getMediaSetContentValues(
             Cursor mediaSetCursor, String categoryId, String authority, String mimeTypes) {
 
diff --git a/tests/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorkerTest.java b/tests/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorkerTest.java
index 3f7b2d262..c318151d5 100644
--- a/tests/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorkerTest.java
+++ b/tests/src/com/android/providers/media/photopicker/sync/MediaSetsResetWorkerTest.java
@@ -17,6 +17,10 @@
 package com.android.providers.media.photopicker.sync;
 
 import static com.android.providers.media.photopicker.PickerSyncController.LOCAL_PICKER_PROVIDER_AUTHORITY;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_CLOUD_ONLY;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_AUTHORITY;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_CATEGORY_ID;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_SYNC_SOURCE;
 import static com.android.providers.media.photopicker.sync.SyncWorkerTestUtils.initializeTestWorkManager;
 import static com.android.providers.media.photopicker.util.PickerDbTestUtils.CLOUD_ID_1;
 import static com.android.providers.media.photopicker.util.PickerDbTestUtils.CLOUD_ID_2;
@@ -43,6 +47,7 @@ import android.database.sqlite.SQLiteDatabase;
 import android.provider.CloudMediaProviderContract;
 
 import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.work.Data;
 import androidx.work.OneTimeWorkRequest;
 import androidx.work.WorkInfo;
 import androidx.work.WorkManager;
@@ -65,6 +70,7 @@ import org.mockito.Mock;
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.ExecutionException;
 
 public class MediaSetsResetWorkerTest {
@@ -147,6 +153,10 @@ public class MediaSetsResetWorkerTest {
         // Setup
         final OneTimeWorkRequest request =
                 new OneTimeWorkRequest.Builder(MediaSetsResetWorker.class)
+                        .setInputData(new Data(Map.of(
+                                SYNC_WORKER_INPUT_SYNC_SOURCE, SYNC_CLOUD_ONLY,
+                                SYNC_WORKER_INPUT_CATEGORY_ID, mCategoryId,
+                                SYNC_WORKER_INPUT_AUTHORITY, mAuthority)))
                         .build();
 
         final WorkManager workManager = WorkManager.getInstance(mContext);
diff --git a/tests/src/com/android/providers/media/photopicker/sync/PickerSyncManagerTest.java b/tests/src/com/android/providers/media/photopicker/sync/PickerSyncManagerTest.java
index 60e43e934..59473d7e1 100644
--- a/tests/src/com/android/providers/media/photopicker/sync/PickerSyncManagerTest.java
+++ b/tests/src/com/android/providers/media/photopicker/sync/PickerSyncManagerTest.java
@@ -800,6 +800,15 @@ public class PickerSyncManagerTest {
         assertThat(resetRequest.getWorkSpec().isPeriodic()).isFalse();
         assertThat(resetRequest.getWorkSpec().id).isNotNull();
         assertThat(resetRequest.getWorkSpec().constraints.requiresBatteryNotLow()).isFalse();
+        assertThat(resetRequest.getWorkSpec().input
+                .getInt(SYNC_WORKER_INPUT_SYNC_SOURCE, -1))
+                .isEqualTo(SYNC_LOCAL_ONLY);
+        assertThat(resetRequest.getWorkSpec().input
+                .getString(SYNC_WORKER_INPUT_CATEGORY_ID))
+                .isEqualTo(categoryId);
+        assertThat(resetRequest.getWorkSpec().input
+                .getString(SYNC_WORKER_INPUT_AUTHORITY))
+                .isEqualTo(SearchProvider.AUTHORITY);
 
         WorkRequest syncRequest = workRequestList.get(1).get(0);
         assertThat(syncRequest.getWorkSpec().workerClassName)
@@ -860,6 +869,15 @@ public class PickerSyncManagerTest {
         assertThat(resetRequest.getWorkSpec().isPeriodic()).isFalse();
         assertThat(resetRequest.getWorkSpec().id).isNotNull();
         assertThat(resetRequest.getWorkSpec().constraints.requiresBatteryNotLow()).isFalse();
+        assertThat(resetRequest.getWorkSpec().input
+                .getInt(SYNC_WORKER_INPUT_SYNC_SOURCE, -1))
+                .isEqualTo(SYNC_CLOUD_ONLY);
+        assertThat(resetRequest.getWorkSpec().input
+                .getString(SYNC_WORKER_INPUT_CATEGORY_ID))
+                .isEqualTo(categoryId);
+        assertThat(resetRequest.getWorkSpec().input
+                .getString(SYNC_WORKER_INPUT_AUTHORITY))
+                .isEqualTo(SearchProvider.AUTHORITY);
 
         WorkRequest syncRequest = workRequestList.get(1).get(0);
         assertThat(syncRequest.getWorkSpec().workerClassName)
diff --git a/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtilTest.java b/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtilTest.java
index cbf7baa36..bdb7944d3 100644
--- a/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtilTest.java
+++ b/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaInMediaSetsDatabaseUtilTest.java
@@ -620,6 +620,7 @@ public class MediaInMediaSetsDatabaseUtilTest {
         assertAddMediaOperation(mFacade, CLOUD_PROVIDER, cursor3, 1);
 
         Long mediaSetPickerId = 1L;
+        Long secondMediaSetPickerId = 2L;
 
         final long cloudRowsInsertedCount = MediaInMediaSetsDatabaseUtil.cacheMediaOfMediaSet(
                 mDatabase, List.of(
@@ -632,10 +633,22 @@ public class MediaInMediaSetsDatabaseUtilTest {
                 .that(cloudRowsInsertedCount)
                 .isEqualTo(3);
 
+        final long secondCloudRowsInsertedCount = MediaInMediaSetsDatabaseUtil.cacheMediaOfMediaSet(
+                mDatabase, List.of(
+                        getContentValues(null, CLOUD_ID_3, secondMediaSetPickerId),
+                        getContentValues(LOCAL_ID_2, CLOUD_ID_2, secondMediaSetPickerId),
+                        getContentValues(LOCAL_ID_1, CLOUD_ID_1, secondMediaSetPickerId)
+                ), CLOUD_PROVIDER);
+
+        assertWithMessage("Unexpected number of rows inserted in the search results table")
+                .that(secondCloudRowsInsertedCount)
+                .isEqualTo(3);
+
         // Clear the data
-        MediaInMediaSetsDatabaseUtil.clearMediaInMediaSetsCache(mDatabase);
+        MediaInMediaSetsDatabaseUtil.clearMediaInMediaSetsCache(
+                mDatabase, List.of(mediaSetPickerId.toString()));
 
-        // Retrieved cursor should be empty
+        // Retrieved cursor for mediaSetPickerId should be empty
         Bundle extras = new Bundle();
         extras.putInt("page_size", 100);
         extras.putStringArrayList("providers",
@@ -648,6 +661,19 @@ public class MediaInMediaSetsDatabaseUtilTest {
         assertNotNull(mediaCursor);
         assertEquals(/*expected*/0, /*actual*/ mediaCursor.getCount());
 
+        // Retrieved cursor for secondmediaSetPickerId should be non-empty
+        Bundle secondExtras = new Bundle();
+        secondExtras.putInt("page_size", 100);
+        secondExtras.putStringArrayList("providers",
+                new ArrayList<>(Arrays.asList(LOCAL_PROVIDER, CLOUD_PROVIDER)));
+        secondExtras.putString("intent_action", MediaStore.ACTION_PICK_IMAGES);
+        MediaInMediaSetsQuery secondMediaInMediaSetQuery = new MediaInMediaSetsQuery(
+                secondExtras, secondMediaSetPickerId);
+        Cursor secondMediaCursor = MediaInMediaSetsDatabaseUtil.queryMediaInMediaSet(
+                mMockSyncController, secondMediaInMediaSetQuery, LOCAL_PROVIDER, CLOUD_PROVIDER);
+        assertNotNull(secondMediaCursor);
+        assertEquals(/*expected*/3, /*actual*/ secondMediaCursor.getCount());
+
     }
 
     private ContentValues getContentValues(
diff --git a/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtilsTest.java b/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtilsTest.java
index 336bccc4a..432f76a32 100644
--- a/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtilsTest.java
+++ b/tests/src/com/android/providers/media/photopicker/v2/sqlite/MediaSetsDatabaseUtilsTest.java
@@ -238,7 +238,26 @@ public class MediaSetsDatabaseUtilsTest {
     }
 
     @Test
-    public void testClearMediaSetsCache() throws RequestObsoleteException {
+    public void testGetMediaSetPickerIdsForCategoryId() {
+        Cursor c = getCursorForMediaSetInsertionTest();
+        List<String> mimeTypes = new ArrayList<>();
+        mimeTypes.add(mMimeType);
+
+        long mediaSetsInserted = MediaSetsDatabaseUtil.cacheMediaSets(
+                mDatabase, c, mCategoryId, mAuthority, mimeTypes);
+        // Assert successful insertion
+        assertEquals("Count of inserted media sets should be equal to the cursor size",
+                /*expected*/ c.getCount(), /*actual*/ mediaSetsInserted);
+
+        List<String> mediaSetPickerIds = MediaSetsDatabaseUtil
+                .getMediaSetPickerIdsForGivenCategoryId(mDatabase, mCategoryId, mAuthority);
+        // Assert that the list has some sqlite generated ids
+        assertNotNull(mediaSetPickerIds);
+        assertTrue(!mediaSetPickerIds.isEmpty());
+    }
+
+    @Test
+    public void testClearMediaSetsCache() {
         // Insert metadata into the table
         Cursor c = getCursorForMediaSetInsertionTest();
         List<String> mimeTypes = new ArrayList<>();
@@ -249,10 +268,17 @@ public class MediaSetsDatabaseUtilsTest {
         assertEquals("Count of inserted media sets should be equal to the cursor size",
                 /*expected*/ c.getCount(), /*actual*/ mediaSetsInserted);
 
+        String secondCategoryId = "secCategoryId";
+        int mediaSetsInserted2 = MediaSetsDatabaseUtil.cacheMediaSets(
+                mDatabase, c, secondCategoryId, mAuthority, mimeTypes);
+        assertEquals("Count of inserted media sets should be equal to the cursor size",
+                /*expected*/ c.getCount(), /*actual*/ mediaSetsInserted2);
+
+
         // Delete the inserted items
-        MediaSetsDatabaseUtil.clearMediaSetsCache(mDatabase);
+        MediaSetsDatabaseUtil.clearMediaSetsCache(mDatabase, mCategoryId, mAuthority);
 
-        // Retrieved cursor should be empty
+        // Retrieved cursor should be empty for mCategoryId
         Bundle extras = new Bundle();
         extras.putString(MediaSetsSyncRequestParams.KEY_PARENT_CATEGORY_AUTHORITY, mAuthority);
         extras.putString(MediaSetsSyncRequestParams.KEY_PARENT_CATEGORY_ID, mCategoryId);
@@ -265,6 +291,23 @@ public class MediaSetsDatabaseUtilsTest {
                 mDatabase, requestParams);
         assertNotNull(mediaSetCursor);
         assertEquals(/*expected*/ 0, /*actual*/ mediaSetCursor.getCount());
+
+        // Retrieved cursor should not be empty for secondCategoryId since only the media sets for
+        // mCategoryId have been deleted in the previous call
+        Bundle secondExtras = new Bundle();
+        secondExtras.putString(
+                MediaSetsSyncRequestParams.KEY_PARENT_CATEGORY_AUTHORITY, mAuthority);
+        secondExtras.putString(MediaSetsSyncRequestParams.KEY_PARENT_CATEGORY_ID, secondCategoryId);
+        secondExtras.putStringArrayList(
+                MediaSetsSyncRequestParams.KEY_MIME_TYPES,
+                new ArrayList<String>(mimeTypes));
+        MediaSetsSyncRequestParams secondRequestParams =
+                new MediaSetsSyncRequestParams(secondExtras);
+
+        Cursor secondMediaSetCursor = MediaSetsDatabaseUtil.getMediaSetsForCategory(
+                mDatabase, secondRequestParams);
+        assertNotNull(secondMediaSetCursor);
+        assertEquals(/*expected*/ 1, /*actual*/ secondMediaSetCursor.getCount());
     }
 
     private Cursor getCursorForMediaSetInsertionTest() {