Add tests for search results sync worker

Bug: 361042632
Test: atest SearchResultsSyncWorkerTest
Test: atest SearchRequestDatabaseUtilTest
Flag: com.android.providers.media.flags.enable_photopicker_search
Change-Id: I8365803f0a3d676d70761d567c45acc0e23cebf5

8 files changed, 842 insertions, 87 deletions

diff --git a/apex/framework/java/android/provider/CloudMediaProvider.java b/apex/framework/java/android/provider/CloudMediaProvider.java
index 1d13426ad..273182752 100644
--- a/apex/framework/java/android/provider/CloudMediaProvider.java
+++ b/apex/framework/java/android/provider/CloudMediaProvider.java
@@ -903,80 +903,60 @@ public abstract class CloudMediaProvider extends ContentProvider {
                         System.currentTimeMillis() - startTime, mAuthority);
                 break;
             case MATCH_MEDIA_CATEGORIES:
-                if (Flags.cloudMediaProviderSearch()) {
-                    final String parentCategoryId = queryArgs.getString(KEY_PARENT_CATEGORY_ID);
-                    queryArgs.remove(KEY_PARENT_CATEGORY_ID);
-                    result = onQueryMediaCategories(parentCategoryId, queryArgs, cancellationSignal
-                    );
-                    CmpApiVerifier.verifyApiResult(new CmpApiResult(
-                                    CmpApiVerifier.CloudMediaProviderApis.OnQueryMediaCategories,
-                                    result),
-                            System.currentTimeMillis() - startTime, mAuthority);
-                } else {
-                    throw new UnsupportedOperationException("Unsupported Uri " + uri);
-                }
+                final String parentCategoryId = queryArgs.getString(KEY_PARENT_CATEGORY_ID);
+                queryArgs.remove(KEY_PARENT_CATEGORY_ID);
+                result = onQueryMediaCategories(parentCategoryId, queryArgs, cancellationSignal
+                );
+                CmpApiVerifier.verifyApiResult(new CmpApiResult(
+                                CmpApiVerifier.CloudMediaProviderApis.OnQueryMediaCategories,
+                                result),
+                        System.currentTimeMillis() - startTime, mAuthority);
                 break;
             case MATCH_MEDIA_SETS:
-                if (Flags.cloudMediaProviderSearch()) {
-                    final String mediaCategoryId = queryArgs.getString(KEY_MEDIA_CATEGORY_ID);
-                    queryArgs.remove(KEY_MEDIA_CATEGORY_ID);
-                    result = onQueryMediaSets(mediaCategoryId, queryArgs, cancellationSignal);
-                    CmpApiVerifier.verifyApiResult(new CmpApiResult(
-                                    CmpApiVerifier.CloudMediaProviderApis.OnQueryMediaSets,
-                                    result),
-                            System.currentTimeMillis() - startTime, mAuthority);
-                } else {
-                    throw new UnsupportedOperationException("Unsupported Uri " + uri);
-                }
+                final String mediaCategoryId = queryArgs.getString(KEY_MEDIA_CATEGORY_ID);
+                queryArgs.remove(KEY_MEDIA_CATEGORY_ID);
+                result = onQueryMediaSets(mediaCategoryId, queryArgs, cancellationSignal);
+                CmpApiVerifier.verifyApiResult(new CmpApiResult(
+                                CmpApiVerifier.CloudMediaProviderApis.OnQueryMediaSets,
+                                result),
+                        System.currentTimeMillis() - startTime, mAuthority);
                 break;
             case MATCH_SEARCH_SUGGESTION:
-                if (Flags.cloudMediaProviderSearch()) {
-                    final String prefixText = queryArgs.getString(KEY_PREFIX_TEXT);
-                    queryArgs.remove(KEY_PREFIX_TEXT);
-                    result = onQuerySearchSuggestions(prefixText, queryArgs, cancellationSignal);
-                    CmpApiVerifier.verifyApiResult(new CmpApiResult(
-                                    CmpApiVerifier.CloudMediaProviderApis.OnQuerySearchSuggestions,
-                                    result),
-                            System.currentTimeMillis() - startTime, mAuthority);
-                } else {
-                    throw new UnsupportedOperationException("Unsupported Uri " + uri);
-                }
+                final String prefixText = queryArgs.getString(KEY_PREFIX_TEXT);
+                queryArgs.remove(KEY_PREFIX_TEXT);
+                result = onQuerySearchSuggestions(prefixText, queryArgs, cancellationSignal);
+                CmpApiVerifier.verifyApiResult(new CmpApiResult(
+                                CmpApiVerifier.CloudMediaProviderApis.OnQuerySearchSuggestions,
+                                result),
+                        System.currentTimeMillis() - startTime, mAuthority);
                 break;
             case MATCH_MEDIAS_IN_MEDIA_SET:
-                if (Flags.cloudMediaProviderSearch()) {
-                    final String mediaSetId = queryArgs.getString(KEY_MEDIA_SET_ID);
-                    queryArgs.remove(KEY_MEDIA_SET_ID);
-                    result = onQueryMediaInMediaSet(mediaSetId, queryArgs, cancellationSignal);
-                    CmpApiVerifier.verifyApiResult(new CmpApiResult(
-                                    CmpApiVerifier.CloudMediaProviderApis.OnQueryMediaInMediaSet,
-                                    result),
-                            System.currentTimeMillis() - startTime, mAuthority);
-                } else {
-                    throw new UnsupportedOperationException("Unsupported Uri " + uri);
-                }
+                final String mediaSetId = queryArgs.getString(KEY_MEDIA_SET_ID);
+                queryArgs.remove(KEY_MEDIA_SET_ID);
+                result = onQueryMediaInMediaSet(mediaSetId, queryArgs, cancellationSignal);
+                CmpApiVerifier.verifyApiResult(new CmpApiResult(
+                                CmpApiVerifier.CloudMediaProviderApis.OnQueryMediaInMediaSet,
+                                result),
+                        System.currentTimeMillis() - startTime, mAuthority);
                 break;
             case MATCH_SEARCH:
-                if (Flags.cloudMediaProviderSearch()) {
-                    final String searchText = queryArgs.getString(KEY_SEARCH_TEXT);
-                    queryArgs.remove(KEY_SEARCH_TEXT);
-                    final String mediaSetId = queryArgs.getString(KEY_MEDIA_SET_ID);
-                    queryArgs.remove(KEY_MEDIA_SET_ID);
-                    if (mediaSetId != null) {
-                        result = onSearchMedia(mediaSetId, searchText, queryArgs, cancellationSignal
-                        );
-                    } else if (searchText != null) {
-                        result = onSearchMedia(searchText, queryArgs, cancellationSignal);
-                    } else {
-                        throw new IllegalArgumentException("both suggested media set id "
-                                + "and search text can not be null together");
-                    }
-                    CmpApiVerifier.verifyApiResult(new CmpApiResult(
-                                    CmpApiVerifier.CloudMediaProviderApis.OnSearchMedia,
-                                    result),
-                            System.currentTimeMillis() - startTime, mAuthority);
+                final String searchText = queryArgs.getString(KEY_SEARCH_TEXT);
+                queryArgs.remove(KEY_SEARCH_TEXT);
+                final String searchMediaSetId = queryArgs.getString(KEY_MEDIA_SET_ID);
+                queryArgs.remove(KEY_MEDIA_SET_ID);
+                if (searchMediaSetId != null) {
+                    result = onSearchMedia(
+                            searchMediaSetId, searchText, queryArgs, cancellationSignal);
+                } else if (searchText != null) {
+                    result = onSearchMedia(searchText, queryArgs, cancellationSignal);
                 } else {
-                    throw new UnsupportedOperationException("Unsupported Uri " + uri);
+                    throw new IllegalArgumentException("both suggested media set id "
+                            + "and search text can not be null together");
                 }
+                CmpApiVerifier.verifyApiResult(new CmpApiResult(
+                                CmpApiVerifier.CloudMediaProviderApis.OnSearchMedia,
+                                result),
+                        System.currentTimeMillis() - startTime, mAuthority);
                 break;
             default:
                 throw new UnsupportedOperationException("Unsupported Uri " + uri);
diff --git a/tests/AndroidManifest.xml b/tests/AndroidManifest.xml
index 5c928b049..f57aaed20 100644
--- a/tests/AndroidManifest.xml
+++ b/tests/AndroidManifest.xml
@@ -97,6 +97,12 @@
           </intent-filter>
         </provider>
 
+        <provider android:name="com.android.providers.media.cloudproviders.SearchProvider"
+            android:authorities="com.android.providers.media.photopicker.tests.cloud_search_provider"
+            android:permission="com.android.providers.media.permission.MANAGE_CLOUD_MEDIA_PROVIDERS"
+            android:exported="true">
+        </provider>
+
         <provider android:name="com.android.providers.media.cloudproviders.CloudProviderPrimary"
                   android:authorities="com.android.providers.media.photopicker.tests.cloud_primary"
                   android:permission="com.android.providers.media.permission.MANAGE_CLOUD_MEDIA_PROVIDERS"
@@ -131,7 +137,7 @@
 
         <provider android:name="com.android.providers.media.photopickersearch.CloudMediaProviderSearch"
             android:permission="com.android.providers.media.permission.MANAGE_CLOUD_MEDIA_PROVIDERS"
-            android:authorities="com.android.providers.media.photopickersearch.tests.cloud_provider_search"
+            android:authorities="com.android.providers.media.photopicker.tests.cloud_provider_for_search_client"
             android:exported="true">
         </provider>
 
diff --git a/tests/src/com/android/providers/media/cloudproviders/SearchProvider.java b/tests/src/com/android/providers/media/cloudproviders/SearchProvider.java
new file mode 100644
index 000000000..0ec01c00f
--- /dev/null
+++ b/tests/src/com/android/providers/media/cloudproviders/SearchProvider.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.providers.media.cloudproviders;
+
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.CLOUD_ID_1;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.CLOUD_ID_2;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.CLOUD_ID_3;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.CLOUD_ID_4;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.LOCAL_ID_1;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.LOCAL_ID_2;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.getCloudMediaCursor;
+import static com.android.providers.media.photopicker.util.PickerDbTestUtils.getLocalMediaCursor;
+
+import android.content.res.AssetFileDescriptor;
+import android.database.Cursor;
+import android.database.MergeCursor;
+import android.graphics.Point;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.ParcelFileDescriptor;
+import android.provider.CloudMediaProvider;
+
+import java.io.FileNotFoundException;
+import java.util.List;
+
+public class SearchProvider extends CloudMediaProvider {
+    public static final String AUTHORITY =
+            "com.android.providers.media.photopicker.tests.cloud_search_provider";
+
+    public static final MergeCursor DEFAULT_CLOUD_MEDIA = new MergeCursor(List.of(
+            getCloudMediaCursor(CLOUD_ID_1, LOCAL_ID_1, 0),
+            getCloudMediaCursor(CLOUD_ID_2, LOCAL_ID_2, 0),
+            getCloudMediaCursor(CLOUD_ID_3, null, 0),
+            getCloudMediaCursor(CLOUD_ID_4, null, 0)
+    ).toArray(new Cursor[0]));
+
+    public static final MergeCursor DEFAULT_CLOUD_SEARCH_RESULTS = new MergeCursor(List.of(
+            getCloudMediaCursor(CLOUD_ID_1, LOCAL_ID_1, 1),
+            getCloudMediaCursor(CLOUD_ID_3, null, 0)
+    ).toArray(new Cursor[0]));
+
+    public static final MergeCursor DEFAULT_LOCAL_SEARCH_RESULTS = new MergeCursor(List.of(
+            getLocalMediaCursor(LOCAL_ID_1, 1),
+            getLocalMediaCursor(LOCAL_ID_2, 0)
+    ).toArray(new Cursor[0]));
+
+    private static Cursor sSearchResults = DEFAULT_CLOUD_SEARCH_RESULTS;
+
+    @Override
+    public Cursor onSearchMedia(String mediaSetId, String fallbackSearchText,
+                                Bundle extras, CancellationSignal cancellationSignal) {
+        return sSearchResults;
+    }
+
+    @Override
+    public Cursor onSearchMedia(String searchText,
+                                Bundle extras, CancellationSignal cancellationSignal) {
+        return sSearchResults;
+    }
+
+    @Override
+    public boolean onCreate() {
+        return true;
+    }
+
+    @Override
+    public Cursor onQueryMedia(Bundle extras) {
+        throw new UnsupportedOperationException("onQueryMedia not supported");
+    }
+
+    @Override
+    public Cursor onQueryDeletedMedia(Bundle extras) {
+        throw new UnsupportedOperationException("onQueryDeletedMedia not supported");
+    }
+
+    @Override
+    public AssetFileDescriptor onOpenPreview(
+            String mediaId,
+            Point size,
+            Bundle extras,
+            CancellationSignal signal) throws FileNotFoundException {
+        throw new UnsupportedOperationException("onOpenPreview not supported");
+    }
+
+    @Override
+    public ParcelFileDescriptor onOpenMedia(
+            String mediaId,
+            Bundle extras,
+            CancellationSignal signal) throws FileNotFoundException {
+        throw new UnsupportedOperationException("onOpenMedia not supported");
+    }
+
+    @Override
+    public Bundle onGetMediaCollectionInfo(Bundle extras) {
+        throw new UnsupportedOperationException("onGetMediaCollectionInfo not supported");
+    }
+
+    public static void setSearchResults(Cursor searchResults) {
+        sSearchResults = searchResults;
+    }
+
+    public static Cursor getSearchResults() {
+        return sSearchResults;
+    }
+}
diff --git a/tests/src/com/android/providers/media/photopicker/sync/SearchResultsSyncWorkerTest.java b/tests/src/com/android/providers/media/photopicker/sync/SearchResultsSyncWorkerTest.java
new file mode 100644
index 000000000..8ac0fe78b
--- /dev/null
+++ b/tests/src/com/android/providers/media/photopicker/sync/SearchResultsSyncWorkerTest.java
@@ -0,0 +1,583 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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_LOCAL_ONLY;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_SYNC_SOURCE;
+import static com.android.providers.media.photopicker.sync.SearchResultsSyncWorker.SYNC_COMPLETE_RESUME_KEY;
+import static com.android.providers.media.photopicker.sync.SyncWorkerTestUtils.getCloudSearchResultsSyncInputData;
+import static com.android.providers.media.photopicker.sync.SyncWorkerTestUtils.getInvalidSearchResultsSyncInputData;
+import static com.android.providers.media.photopicker.sync.SyncWorkerTestUtils.getLocalSearchResultsSyncInputData;
+import static com.android.providers.media.photopicker.sync.SyncWorkerTestUtils.initializeTestWorkManager;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.platform.test.annotations.EnableFlags;
+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;
+
+import com.android.providers.media.cloudproviders.SearchProvider;
+import com.android.providers.media.flags.Flags;
+import com.android.providers.media.photopicker.PickerSyncController;
+import com.android.providers.media.photopicker.data.PickerDatabaseHelper;
+import com.android.providers.media.photopicker.data.PickerDbFacade;
+import com.android.providers.media.photopicker.v2.model.SearchSuggestionRequest;
+import com.android.providers.media.photopicker.v2.model.SearchSuggestionType;
+import com.android.providers.media.photopicker.v2.model.SearchTextRequest;
+import com.android.providers.media.photopicker.v2.sqlite.PickerSQLConstants;
+import com.android.providers.media.photopicker.v2.sqlite.SearchRequestDatabaseUtil;
+import com.android.providers.media.photopicker.v2.sqlite.SelectSQLiteQueryBuilder;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+
+import java.io.File;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+@EnableFlags(Flags.FLAG_CLOUD_MEDIA_PROVIDER_SEARCH)
+public class SearchResultsSyncWorkerTest {
+    @Mock
+    private PickerSyncController mMockSyncController;
+    private Context mContext;
+    private SQLiteDatabase mDatabase;
+    private PickerDbFacade mFacade;
+
+    @Before
+    public void setup() {
+        initMocks(this);
+
+        PickerSyncController.setInstance(mMockSyncController);
+        mContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+        initializeTestWorkManager(mContext);
+
+        File dbPath = mContext.getDatabasePath(PickerDatabaseHelper.PICKER_DATABASE_NAME);
+        dbPath.delete();
+        PickerDatabaseHelper helper = new PickerDatabaseHelper(mContext);
+        mDatabase = helper.getWritableDatabase();
+        mFacade = new PickerDbFacade(
+                mContext, new PickerSyncLockManager(), LOCAL_PICKER_PROVIDER_AUTHORITY);
+        mFacade.setCloudProvider(SearchProvider.AUTHORITY);
+
+        doReturn(LOCAL_PICKER_PROVIDER_AUTHORITY).when(mMockSyncController).getLocalProvider();
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController).getCloudProvider();
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController)
+                .getCloudProviderOrDefault(any());
+        doReturn(mFacade).when(mMockSyncController).getDbFacade();
+        doReturn(new PickerSyncLockManager()).when(mMockSyncController).getPickerSyncLockManager();
+    }
+
+    @Test
+    public void testInvalidSyncSource()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(
+                                getInvalidSearchResultsSyncInputData(/* searchRequestId */ 10))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.FAILED);
+    }
+
+    @Test
+    public void testMissingSearchRequestId()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(
+                                new Data(Map.of(SYNC_WORKER_INPUT_SYNC_SOURCE, SYNC_LOCAL_ONLY)))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.FAILED);
+    }
+
+    @Test
+    public void testInvalidSearchRequestId()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getLocalSearchResultsSyncInputData(/* searchRequestId */ 10))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.FAILED);
+    }
+
+    @Test
+    public void testInvalidAlbumSuggestionsSearchRequestId()
+            throws ExecutionException, InterruptedException {
+        // Setup cloud search results sync for local album
+        SearchSuggestionRequest searchRequest = new SearchSuggestionRequest(
+                null,
+                "search text",
+                "media-set-id",
+                SearchProvider.AUTHORITY,
+                SearchSuggestionType.ALBUM,
+                null
+        );
+
+        SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        final int searchRequestId =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+
+        assertWithMessage("Could not find search request is the database " + searchRequest)
+                .that(searchRequestId)
+                .isNotEqualTo(-1);
+
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getLocalSearchResultsSyncInputData(searchRequestId))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.FAILED);
+    }
+
+    @Test
+    public void testTextSearchSyncWithCloudProvider()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        SearchTextRequest searchRequest = new SearchTextRequest(
+                null,
+                "search text",
+                null
+        );
+
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController).getCloudProvider();
+
+        SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        final int searchRequestId =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+
+        assertWithMessage("Could not find search request is the database " + searchRequest)
+                .that(searchRequestId)
+                .isNotEqualTo(-1);
+
+        final Cursor inputCursor = SearchProvider.DEFAULT_CLOUD_SEARCH_RESULTS;
+        SearchProvider.setSearchResults(inputCursor);
+
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getCloudSearchResultsSyncInputData(searchRequestId))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.SUCCEEDED);
+
+        try (Cursor cursor = mDatabase.rawQuery(
+                new SelectSQLiteQueryBuilder(mDatabase).setTables(
+                        PickerSQLConstants.Table.SEARCH_RESULT_MEDIA.name()
+                ).buildQuery(), null
+        )) {
+            assertWithMessage("Cursor should not be null")
+                    .that(cursor)
+                    .isNotNull();
+
+            assertWithMessage("Cursor count is not as expected")
+                    .that(cursor.getCount())
+                    .isEqualTo(inputCursor.getCount());
+
+            if (cursor.moveToFirst() && inputCursor.moveToFirst()) {
+                do {
+                    final ContentValues dbValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(cursor, dbValues);
+
+                    final ContentValues inputValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(inputCursor, inputValues);
+
+                    assertWithMessage("Cloud id is not as expected")
+                            .that(dbValues.getAsString(PickerSQLConstants
+                                    .SearchResultMediaTableColumns.CLOUD_ID.getColumnName()))
+                            .isEqualTo(inputValues.get(CloudMediaProviderContract.MediaColumns.ID));
+
+                    assertWithMessage("Search request id is not as expected")
+                            .that(dbValues.getAsInteger(
+                                    PickerSQLConstants.SearchResultMediaTableColumns
+                                            .SEARCH_REQUEST_ID.getColumnName()))
+                            .isEqualTo(searchRequestId);
+
+                    final String inputMediaStoreUri = inputValues
+                            .getAsString(CloudMediaProviderContract.MediaColumns.MEDIA_STORE_URI);
+                    if (inputMediaStoreUri == null) {
+                        assertWithMessage("Local id is not null")
+                                .that(dbValues.getAsInteger(
+                                        PickerSQLConstants.SearchResultMediaTableColumns
+                                                .LOCAL_ID.getColumnName()))
+                                .isNull();
+                    } else {
+                        assertWithMessage("Local id is not as expected")
+                                .that(dbValues.getAsInteger(
+                                        PickerSQLConstants.SearchResultMediaTableColumns
+                                                .LOCAL_ID.getColumnName()))
+                                .isEqualTo(ContentUris.parseId(Uri.parse(inputMediaStoreUri)));
+                    }
+                } while (cursor.moveToNext() && inputCursor.moveToNext());
+            }
+        }
+    }
+
+    @Test
+    public void testTextSearchSyncWithLocalProvider()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        SearchTextRequest searchRequest = new SearchTextRequest(
+                null,
+                "search text",
+                null
+        );
+
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController).getLocalProvider();
+
+        SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        final int searchRequestId =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+
+        assertWithMessage("Could not find search request is the database " + searchRequest)
+                .that(searchRequestId)
+                .isNotEqualTo(-1);
+
+        final Cursor inputCursor = SearchProvider.DEFAULT_LOCAL_SEARCH_RESULTS;
+        SearchProvider.setSearchResults(inputCursor);
+
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getLocalSearchResultsSyncInputData(searchRequestId))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.SUCCEEDED);
+
+        try (Cursor cursor = mDatabase.rawQuery(
+                new SelectSQLiteQueryBuilder(mDatabase).setTables(
+                        PickerSQLConstants.Table.SEARCH_RESULT_MEDIA.name()
+                ).buildQuery(), null
+        )) {
+            assertWithMessage("Cursor should not be null")
+                    .that(cursor)
+                    .isNotNull();
+
+            assertWithMessage("Cursor count is not as expected")
+                    .that(cursor.getCount())
+                    .isEqualTo(inputCursor.getCount());
+
+            if (cursor.moveToFirst() && inputCursor.moveToFirst()) {
+                do {
+                    final ContentValues dbValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(cursor, dbValues);
+
+                    final ContentValues inputValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(inputCursor, inputValues);
+
+                    assertWithMessage("Local id is not as expected")
+                            .that(dbValues.getAsString(PickerSQLConstants
+                                    .SearchResultMediaTableColumns.LOCAL_ID.getColumnName()))
+                            .isEqualTo(inputValues.get(CloudMediaProviderContract.MediaColumns.ID));
+
+                    assertWithMessage("Cloud id is not null")
+                            .that(dbValues.getAsString(PickerSQLConstants
+                                    .SearchResultMediaTableColumns.CLOUD_ID.getColumnName()))
+                            .isNull();
+
+                    assertWithMessage("Search request id is not as expected")
+                            .that(dbValues.getAsInteger(
+                                    PickerSQLConstants.SearchResultMediaTableColumns
+                                            .SEARCH_REQUEST_ID.getColumnName()))
+                            .isEqualTo(searchRequestId);
+                } while (cursor.moveToNext() && inputCursor.moveToNext());
+            }
+        }
+    }
+
+    @Test
+    public void testSuggestionSearchSyncWithCloudProvider()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        SearchSuggestionRequest searchRequest = new SearchSuggestionRequest(
+                null,
+                "search text",
+                "media-set-id",
+                LOCAL_PICKER_PROVIDER_AUTHORITY,
+                SearchSuggestionType.FACE,
+                null
+        );
+
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController).getCloudProvider();
+
+        SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        final int searchRequestId =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+
+        assertWithMessage("Could not find search request is the database " + searchRequest)
+                .that(searchRequestId)
+                .isNotEqualTo(-1);
+
+        final Cursor inputCursor = SearchProvider.DEFAULT_CLOUD_SEARCH_RESULTS;
+        SearchProvider.setSearchResults(inputCursor);
+
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getCloudSearchResultsSyncInputData(searchRequestId))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.SUCCEEDED);
+
+        try (Cursor cursor = mDatabase.rawQuery(
+                new SelectSQLiteQueryBuilder(mDatabase).setTables(
+                        PickerSQLConstants.Table.SEARCH_RESULT_MEDIA.name()
+                ).buildQuery(), null
+        )) {
+            assertWithMessage("Cursor should not be null")
+                    .that(cursor)
+                    .isNotNull();
+
+            assertWithMessage("Cursor count is not as expected")
+                    .that(cursor.getCount())
+                    .isEqualTo(inputCursor.getCount());
+
+            if (cursor.moveToFirst() && inputCursor.moveToFirst()) {
+                do {
+                    final ContentValues dbValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(cursor, dbValues);
+
+                    final ContentValues inputValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(inputCursor, inputValues);
+
+                    assertWithMessage("Cloud id is not as expected")
+                            .that(dbValues.getAsString(PickerSQLConstants
+                                    .SearchResultMediaTableColumns.CLOUD_ID.getColumnName()))
+                            .isEqualTo(inputValues.get(CloudMediaProviderContract.MediaColumns.ID));
+
+                    assertWithMessage("Search request id is not as expected")
+                            .that(dbValues.getAsInteger(
+                                    PickerSQLConstants.SearchResultMediaTableColumns
+                                            .SEARCH_REQUEST_ID.getColumnName()))
+                            .isEqualTo(searchRequestId);
+
+                    final String inputMediaStoreUri = inputValues
+                            .getAsString(CloudMediaProviderContract.MediaColumns.MEDIA_STORE_URI);
+                    if (inputMediaStoreUri == null) {
+                        assertWithMessage("Local id is not null")
+                                .that(dbValues.getAsInteger(
+                                        PickerSQLConstants.SearchResultMediaTableColumns
+                                                .LOCAL_ID.getColumnName()))
+                                .isNull();
+                    } else {
+                        assertWithMessage("Local id is not as expected")
+                                .that(dbValues.getAsInteger(
+                                        PickerSQLConstants.SearchResultMediaTableColumns
+                                                .LOCAL_ID.getColumnName()))
+                                .isEqualTo(ContentUris.parseId(Uri.parse(inputMediaStoreUri)));
+                    }
+                } while (cursor.moveToNext() && inputCursor.moveToNext());
+            }
+        }
+    }
+
+    @Test
+    public void testSuggestionSearchSyncWithLocalProvider()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        SearchSuggestionRequest searchRequest = new SearchSuggestionRequest(
+                null,
+                "search text",
+                "media-set-id",
+                SearchProvider.AUTHORITY,
+                SearchSuggestionType.FACE,
+                "Random-resume-key"
+        );
+
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController).getLocalProvider();
+
+        SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        final int searchRequestId =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+
+        assertWithMessage("Could not find search request is the database " + searchRequest)
+                .that(searchRequestId)
+                .isNotEqualTo(-1);
+
+        final Cursor inputCursor = SearchProvider.DEFAULT_LOCAL_SEARCH_RESULTS;
+        SearchProvider.setSearchResults(inputCursor);
+
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getLocalSearchResultsSyncInputData(searchRequestId))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.SUCCEEDED);
+
+        try (Cursor cursor = mDatabase.rawQuery(
+                new SelectSQLiteQueryBuilder(mDatabase).setTables(
+                        PickerSQLConstants.Table.SEARCH_RESULT_MEDIA.name()
+                ).buildQuery(), null
+        )) {
+            assertWithMessage("Cursor should not be null")
+                    .that(cursor)
+                    .isNotNull();
+
+            assertWithMessage("Cursor count is not as expected")
+                    .that(cursor.getCount())
+                    .isEqualTo(inputCursor.getCount());
+
+            if (cursor.moveToFirst() && inputCursor.moveToFirst()) {
+                do {
+                    final ContentValues dbValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(cursor, dbValues);
+
+                    final ContentValues inputValues = new ContentValues();
+                    DatabaseUtils.cursorRowToContentValues(inputCursor, inputValues);
+
+                    assertWithMessage("Local id is not as expected")
+                            .that(dbValues.getAsString(PickerSQLConstants
+                                    .SearchResultMediaTableColumns.LOCAL_ID.getColumnName()))
+                            .isEqualTo(inputValues.get(CloudMediaProviderContract.MediaColumns.ID));
+
+                    assertWithMessage("Cloud id is not null")
+                            .that(dbValues.getAsString(PickerSQLConstants
+                                    .SearchResultMediaTableColumns.CLOUD_ID.getColumnName()))
+                            .isNull();
+
+                    assertWithMessage("Search request id is not as expected")
+                            .that(dbValues.getAsInteger(
+                                    PickerSQLConstants.SearchResultMediaTableColumns
+                                            .SEARCH_REQUEST_ID.getColumnName()))
+                            .isEqualTo(searchRequestId);
+                } while (cursor.moveToNext() && inputCursor.moveToNext());
+            }
+        }
+    }
+
+    @Test
+    public void testSyncWasAlreadyComplete()
+            throws ExecutionException, InterruptedException {
+        // Setup
+        SearchSuggestionRequest searchRequest = new SearchSuggestionRequest(
+                null,
+                "search text",
+                "media-set-id",
+                LOCAL_PICKER_PROVIDER_AUTHORITY,
+                SearchSuggestionType.FACE,
+                SYNC_COMPLETE_RESUME_KEY
+        );
+
+        doReturn(SearchProvider.AUTHORITY).when(mMockSyncController).getCloudProvider();
+
+        SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        final int searchRequestId =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+
+        assertWithMessage("Could not find search request is the database " + searchRequest)
+                .that(searchRequestId)
+                .isNotEqualTo(-1);
+
+        final Cursor inputCursor = SearchProvider.DEFAULT_CLOUD_SEARCH_RESULTS;
+        SearchProvider.setSearchResults(inputCursor);
+
+        final OneTimeWorkRequest request =
+                new OneTimeWorkRequest.Builder(SearchResultsSyncWorker.class)
+                        .setInputData(getCloudSearchResultsSyncInputData(searchRequestId))
+                        .build();
+
+        // Test run
+        final WorkManager workManager = WorkManager.getInstance(mContext);
+        workManager.enqueue(request).getResult().get();
+
+        // Verify
+        final WorkInfo workInfo = workManager.getWorkInfoById(request.getId()).get();
+        assertThat(workInfo.getState()).isEqualTo(WorkInfo.State.SUCCEEDED);
+
+        try (Cursor cursor = mDatabase.rawQuery(
+                new SelectSQLiteQueryBuilder(mDatabase).setTables(
+                        PickerSQLConstants.Table.SEARCH_RESULT_MEDIA.name()
+                ).buildQuery(), null
+        )) {
+            assertWithMessage("Cursor should not be null")
+                    .that(cursor)
+                    .isNotNull();
+
+            assertWithMessage("Cursor count is not as expected")
+                    .that(cursor.getCount())
+                    .isEqualTo(0);
+        }
+    }
+}
diff --git a/tests/src/com/android/providers/media/photopicker/sync/SyncWorkerTestUtils.java b/tests/src/com/android/providers/media/photopicker/sync/SyncWorkerTestUtils.java
index 52702ac7f..b21602e64 100644
--- a/tests/src/com/android/providers/media/photopicker/sync/SyncWorkerTestUtils.java
+++ b/tests/src/com/android/providers/media/photopicker/sync/SyncWorkerTestUtils.java
@@ -24,6 +24,7 @@ import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYN
 import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_ALBUM_ID;
 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_RESET_TYPE;
+import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_SEARCH_REQUEST_ID;
 import static com.android.providers.media.photopicker.sync.PickerSyncManager.SYNC_WORKER_INPUT_SYNC_SOURCE;
 
 import android.content.Context;
@@ -108,6 +109,21 @@ public class SyncWorkerTestUtils {
                 SYNC_WORKER_INPUT_ALBUM_ID, albumId));
     }
 
+    public static Data getLocalSearchResultsSyncInputData(int searchRequestId) {
+        return new Data(Map.of(SYNC_WORKER_INPUT_SYNC_SOURCE, SYNC_LOCAL_ONLY,
+                SYNC_WORKER_INPUT_SEARCH_REQUEST_ID, searchRequestId));
+    }
+
+    public static Data getCloudSearchResultsSyncInputData(int searchRequestId) {
+        return new Data(Map.of(SYNC_WORKER_INPUT_SYNC_SOURCE, SYNC_CLOUD_ONLY,
+                SYNC_WORKER_INPUT_SEARCH_REQUEST_ID, searchRequestId));
+    }
+
+    public static Data getInvalidSearchResultsSyncInputData(int searchRequestId) {
+        return new Data(Map.of(SYNC_WORKER_INPUT_SYNC_SOURCE, SYNC_LOCAL_AND_CLOUD,
+                SYNC_WORKER_INPUT_SEARCH_REQUEST_ID, searchRequestId));
+    }
+
     static <W extends Worker> W buildTestWorker(@NonNull Context context,
             @NonNull Class<W> workerClass) {
         return TestWorkerBuilder.from(context, workerClass)
diff --git a/tests/src/com/android/providers/media/photopicker/v2/sqlite/SearchRequestDatabaseUtilTest.java b/tests/src/com/android/providers/media/photopicker/v2/sqlite/SearchRequestDatabaseUtilTest.java
index 923c90107..d55a26674 100644
--- a/tests/src/com/android/providers/media/photopicker/v2/sqlite/SearchRequestDatabaseUtilTest.java
+++ b/tests/src/com/android/providers/media/photopicker/v2/sqlite/SearchRequestDatabaseUtilTest.java
@@ -64,13 +64,13 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long firstInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
         assertWithMessage("Insert search request failed")
                 .that(firstInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
 
         final long secondInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
         assertWithMessage("Second insert for same search request should fail silently")
                 .that(secondInsertResult)
                 .isEqualTo(/* failed to insert row on constraint conflict */ -1);
@@ -88,13 +88,13 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long firstInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, suggestionRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, suggestionRequest);
         assertWithMessage("Insert search request failed")
                 .that(firstInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
 
         final long secondInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, suggestionRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, suggestionRequest);
         assertWithMessage("Second insert for same search request should fail silently")
                 .that(secondInsertResult)
                 .isEqualTo(/* failed to insert row on constraint conflict */ -1);
@@ -110,7 +110,7 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long firstInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest1);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest1);
         assertWithMessage("Insert search request failed")
                 .that(firstInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -127,7 +127,7 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long secondInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest2);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest2);
         assertWithMessage("Insert search request failed")
                 .that(secondInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -140,7 +140,7 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long thirdInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest3);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest3);
         assertWithMessage("Insert search request failed")
                 .that(thirdInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -157,7 +157,7 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long fourthInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest4);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest4);
         assertWithMessage("Insert search request failed")
                 .that(fourthInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -171,7 +171,7 @@ public class SearchRequestDatabaseUtilTest {
         );
 
         final long firstInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, request);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, request);
         assertWithMessage("Insert search request failed")
                 .that(firstInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -181,7 +181,7 @@ public class SearchRequestDatabaseUtilTest {
                 /* searchText */ "volcano"
         );
         final long secondInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, request);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, request);
         assertWithMessage("Second insert for same search request should fail silently")
                 .that(secondInsertResult)
                 .isEqualTo(/* failed to insert row on constraint conflict */ -1);
@@ -191,7 +191,7 @@ public class SearchRequestDatabaseUtilTest {
                 /* searchText */ "volcano"
         );
         final long thirdInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, request);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, request);
         assertWithMessage("Third insert for same search request should fail silently")
                 .that(thirdInsertResult)
                 .isEqualTo(/* failed to insert row on constraint conflict */ -1);
@@ -209,7 +209,7 @@ public class SearchRequestDatabaseUtilTest {
 
 
         final long firstInsertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
         assertWithMessage("Insert search request failed")
                 .that(firstInsertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -240,7 +240,7 @@ public class SearchRequestDatabaseUtilTest {
 
         // Insert a search request
         final long insertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
         assertWithMessage("Insert search request failed")
                 .that(insertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -292,7 +292,7 @@ public class SearchRequestDatabaseUtilTest {
 
         // Insert a search request
         final long insertResult =
-                SearchRequestDatabaseUtil.saveSearchRequestIfRequired(mDatabase, searchRequest);
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
         assertWithMessage("Insert search request failed")
                 .that(insertResult)
                 .isAtLeast(/* minimum row id */ 0);
@@ -335,4 +335,53 @@ public class SearchRequestDatabaseUtilTest {
                 .that(resultSearchSuggestionRequest.getSearchSuggestionType())
                 .isEqualTo(suggestionType);
     }
+
+    @Test
+    public void testResumeKeyUpdate() {
+        final List<String> mimeTypes = List.of("video/mp4", "image/*", "image/gif");
+        final String mediaSetID = "MEDIA-SET-ID";
+        final String authority = "com.random.authority";
+        final SearchSuggestionType suggestionType = SearchSuggestionType.LOCATION;
+        SearchSuggestionRequest searchRequest = new SearchSuggestionRequest(
+                mimeTypes,
+                null,
+                mediaSetID,
+                authority,
+                suggestionType,
+                null
+        );
+
+        // Insert a search request
+        final long insertResult =
+                SearchRequestDatabaseUtil.saveSearchRequest(mDatabase, searchRequest);
+        assertWithMessage("Insert search request failed")
+                .that(insertResult)
+                .isAtLeast(/* minimum row id */ 0);
+
+        // Get search request ID
+        final int searchRequestID =
+                SearchRequestDatabaseUtil.getSearchRequestID(mDatabase, searchRequest);
+        assertWithMessage("Search request ID should exist in DB")
+                .that(searchRequestID)
+                .isAtLeast(0);
+
+        // Fetch search details from search request ID
+        final SearchRequest savedSearchRequest =
+                SearchRequestDatabaseUtil.getSearchRequestDetails(mDatabase, searchRequestID);
+        assertWithMessage("Initial search request resume key is not null")
+                .that(savedSearchRequest.getResumeKey())
+                .isNull();
+
+        // Update resume key and save
+        final String randomResumeKey = "RAMDOM_RESUME_KEY";
+        savedSearchRequest.setResumeKey(randomResumeKey);
+        SearchRequestDatabaseUtil.updateResumeKey(mDatabase, searchRequestID, randomResumeKey);
+
+        // Fetch updated search details from search request ID
+        final SearchRequest updatedSearchRequest =
+                SearchRequestDatabaseUtil.getSearchRequestDetails(mDatabase, searchRequestID);
+        assertWithMessage("Initial search request resume key is not null")
+                .that(updatedSearchRequest.getResumeKey())
+                .isEqualTo(randomResumeKey);
+    }
 }
diff --git a/tests/src/com/android/providers/media/photopickersearch/CloudMediaProviderSearch.java b/tests/src/com/android/providers/media/photopickersearch/CloudMediaProviderSearch.java
index 11066118a..38f6f8f71 100644
--- a/tests/src/com/android/providers/media/photopickersearch/CloudMediaProviderSearch.java
+++ b/tests/src/com/android/providers/media/photopickersearch/CloudMediaProviderSearch.java
@@ -32,7 +32,8 @@ import androidx.annotation.Nullable;
 import java.io.FileNotFoundException;
 
 public class CloudMediaProviderSearch extends CloudMediaProvider {
-
+    public static final String SEARCH_PROVIDER_FOR_PICKER_CLIENT_AUTHORITY =
+            "com.android.providers.media.photopicker.tests.cloud_provider_for_search_client";
     public static final String[] MEDIA_PROJECTIONS =  new String[] {
             CloudMediaProviderContract.MediaColumns.ID
     };
diff --git a/tests/src/com/android/providers/media/photopickersearch/PickerSearchProviderClientTest.java b/tests/src/com/android/providers/media/photopickersearch/PickerSearchProviderClientTest.java
index 4c90f54db..4bd511b8a 100644
--- a/tests/src/com/android/providers/media/photopickersearch/PickerSearchProviderClientTest.java
+++ b/tests/src/com/android/providers/media/photopickersearch/PickerSearchProviderClientTest.java
@@ -17,6 +17,7 @@
 package com.android.providers.media.photopickersearch;
 
 import static com.android.providers.media.photopickersearch.CloudMediaProviderSearch.MEDIA_PROJECTIONS;
+import static com.android.providers.media.photopickersearch.CloudMediaProviderSearch.SEARCH_PROVIDER_FOR_PICKER_CLIENT_AUTHORITY;
 import static com.android.providers.media.photopickersearch.CloudMediaProviderSearch.TEST_MEDIA_CATEGORY_ID;
 import static com.android.providers.media.photopickersearch.CloudMediaProviderSearch.TEST_MEDIA_ID_FROM_SUGGESTED_SEARCH;
 import static com.android.providers.media.photopickersearch.CloudMediaProviderSearch.TEST_MEDIA_ID_FROM_TEXT_SEARCH;
@@ -38,7 +39,7 @@ import androidx.test.InstrumentationRegistry;
 import androidx.test.runner.AndroidJUnit4;
 
 import com.android.providers.media.flags.Flags;
-import com.android.providers.media.photopicker.v2.PickerSearchProviderClient;
+import com.android.providers.media.photopicker.sync.PickerSearchProviderClient;
 
 import org.junit.Before;
 import org.junit.Rule;
@@ -53,9 +54,6 @@ public class PickerSearchProviderClientTest {
     @Rule
     public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
 
-    private static final String CLOUD_SEARCH_PROVIDER_AUTHORITY =
-            "com.android.providers.media.photopickersearch.tests.cloud_provider_search";
-
     private PickerSearchProviderClient mPickerSearchProviderClient;
     private Context mContext;
 
@@ -63,7 +61,8 @@ public class PickerSearchProviderClientTest {
     public void setUp() {
         mContext = InstrumentationRegistry.getTargetContext();
         mPickerSearchProviderClient =
-                PickerSearchProviderClient.create(mContext, CLOUD_SEARCH_PROVIDER_AUTHORITY);
+                PickerSearchProviderClient.create(
+                        mContext, SEARCH_PROVIDER_FOR_PICKER_CLIENT_AUTHORITY);
     }
 
     @Test
@@ -80,7 +79,8 @@ public class PickerSearchProviderClientTest {
     @Test
     public void testFetchSuggestedSearchResultsFromCmp() {
         Cursor cursor = mPickerSearchProviderClient.fetchSearchResultsFromCmp(
-                TEST_SEARCH_SUGGESTION_MEDIA_SET_ID, null, 1, null);
+                TEST_SEARCH_SUGGESTION_MEDIA_SET_ID, null, 1, 100,
+                null, null);
         cursor.moveToFirst();
         assertEquals(TEST_MEDIA_ID_FROM_SUGGESTED_SEARCH, cursor.getString(cursor.getColumnIndex(
                 CloudMediaProviderContract.MediaColumns.ID)));
@@ -90,7 +90,8 @@ public class PickerSearchProviderClientTest {
     @Test
     public void testFetchTextSearchResultsFromCmp() {
         Cursor cursor = mPickerSearchProviderClient.fetchSearchResultsFromCmp(
-                null, "test", 1, null);
+                null, "test", 1, 100,
+                null, null);
         cursor.moveToFirst();
         assertEquals(TEST_MEDIA_ID_FROM_TEXT_SEARCH, cursor.getString(cursor.getColumnIndex(
                 CloudMediaProviderContract.MediaColumns.ID)));