Merge "Add tests for ContactsProvider in clone profile"

5 files changed, 356 insertions, 20 deletions

diff --git a/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java b/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java
index 54984d29..20d6a15e 100644
--- a/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java
+++ b/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java
@@ -1381,6 +1381,25 @@ public abstract class BaseContactsProvider2Test extends PhotoLoadingTestCase {
         assertEquals(timeStamp, time);
     }
 
+    /**
+     * Asserts the equality of two Uri objects, ignoring the order of the query parameters.
+     */
+    protected static void assertUriEquals(Uri expected, Uri actual) {
+        assertEquals(expected.getScheme(), actual.getScheme());
+        assertEquals(expected.getAuthority(), actual.getAuthority());
+        assertEquals(expected.getPath(), actual.getPath());
+        assertEquals(expected.getFragment(), actual.getFragment());
+        Set<String> expectedParameterNames = expected.getQueryParameterNames();
+        Set<String> actualParameterNames = actual.getQueryParameterNames();
+        assertEquals(expectedParameterNames.size(), actualParameterNames.size());
+        assertTrue(expectedParameterNames.containsAll(actualParameterNames));
+        for (String parameterName : expectedParameterNames) {
+            assertEquals(expected.getQueryParameter(parameterName),
+                    actual.getQueryParameter(parameterName));
+        }
+
+    }
+
     protected void setTimeForTest(Long time) {
         Uri uri = Calls.CONTENT_URI.buildUpon()
                 .appendQueryParameter(CallLogProvider.PARAM_KEY_QUERY_FOR_TESTING, "1")
diff --git a/tests/src/com/android/providers/contacts/CloneContactsProvider2Test.java b/tests/src/com/android/providers/contacts/CloneContactsProvider2Test.java
new file mode 100644
index 00000000..18c6cb76
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/CloneContactsProvider2Test.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2022 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.contacts;
+
+import static com.android.providers.contacts.ContactsActor.MockUserManager.CLONE_PROFILE_USER;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.OperationApplicationException;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.provider.ContactsContract;
+import androidx.test.filters.MediumTest;
+import androidx.test.filters.SdkSuppress;
+
+import java.util.ArrayList;
+
+@MediumTest
+@SdkSuppress(minSdkVersion = Build.VERSION_CODES.UPSIDE_DOWN_CAKE, codeName = "UpsideDownCake")
+public class CloneContactsProvider2Test extends BaseContactsProvider2Test {
+
+    private ContactsActor mCloneContactsActor;
+
+    private SynchronousContactsProvider2 getCloneContactsProvider() {
+        return (SynchronousContactsProvider2) mCloneContactsActor.provider;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mCloneContactsActor = new ContactsActor(
+                new ContactsActor.AlteringUserContext(getContext(), CLONE_PROFILE_USER.id),
+                getContextPackageName(), SynchronousContactsProvider2.class, getAuthority());
+        mActor.mockUserManager.setUsers(ContactsActor.MockUserManager.PRIMARY_USER,
+                CLONE_PROFILE_USER);
+        mCloneContactsActor.mockUserManager.setUsers(ContactsActor.MockUserManager.PRIMARY_USER,
+                CLONE_PROFILE_USER);
+        mCloneContactsActor.mockUserManager.myUser = CLONE_PROFILE_USER.id;
+        getCloneContactsProvider().wipeData();
+    }
+
+    private ContentValues getSampleContentValues() {
+        ContentValues values = new ContentValues();
+        values.put(ContactsContract.RawContacts.ACCOUNT_NAME, "test@test.com");
+        values.put(ContactsContract.RawContacts.ACCOUNT_TYPE, "test.com");
+        values.put(ContactsContract.RawContacts.CUSTOM_RINGTONE, "custom");
+        values.put(ContactsContract.RawContacts.STARRED, "1");
+        return values;
+    }
+
+    private void assertEqualContentValues(ContentValues contentValues, Cursor cursor) {
+        assertEquals(contentValues.get(ContactsContract.RawContacts.ACCOUNT_NAME),
+                cursor.getString(cursor.getColumnIndex(ContactsContract.RawContacts.ACCOUNT_NAME)));
+        assertEquals(contentValues.get(ContactsContract.RawContacts.ACCOUNT_TYPE),
+                cursor.getString(cursor.getColumnIndex(ContactsContract.RawContacts.ACCOUNT_TYPE)));
+        assertEquals(contentValues.get(ContactsContract.RawContacts.CUSTOM_RINGTONE),
+                cursor.getString(cursor.getColumnIndex(
+                        ContactsContract.RawContacts.CUSTOM_RINGTONE)));
+        assertEquals(contentValues.get(ContactsContract.RawContacts.STARRED),
+                cursor.getString(cursor.getColumnIndex(
+                        ContactsContract.RawContacts.STARRED)));
+    }
+
+    private void assertRejectedApplyBatchResults(ContentProviderResult[] res,
+            ArrayList<ContentProviderOperation> ops) {
+        assertEquals(ops.size(), res.length);
+        for (int i = 0;i < ops.size();i++) {
+            Uri expectedUri = ops.get(i).getUri()
+                    .buildUpon()
+                    .appendPath("0")
+                    .build();
+            assertUriEquals(expectedUri, res[i].uri);
+        }
+    }
+
+    /**
+     * Asserts that no contacts are returned when queried by the given contacts actor
+     */
+    private void assertContactsProviderEmpty(ContactsActor contactsActor) {
+        Cursor cursor = contactsActor.resolver.query(ContactsContract.RawContacts.CONTENT_URI,
+                new String[]{ContactsContract.RawContactsEntity._ID},
+                null /* queryArgs */, null /* cancellationSignal */);
+        assertNotNull(cursor);
+        assertEquals(cursor.getCount(), 0);
+    }
+
+    private long insertRawContactsThroughPrimaryProvider(ContentValues values) {
+        Uri resultUri = mActor.resolver.insert(ContactsContract.RawContacts.CONTENT_URI,
+                values);
+        assertNotNull(resultUri);
+        return ContentUris.parseId(resultUri);
+    }
+
+    public void testAreContactWritesEnabled() {
+        // Check that writes are disabled for clone CP2
+        ContactsProvider2 cloneContactsProvider =
+                (ContactsProvider2) mCloneContactsActor.provider;
+        assertFalse(cloneContactsProvider.areContactWritesEnabled());
+
+        // Check that writes are enabled for primary CP2
+        ContactsProvider2 primaryContactsProvider = (ContactsProvider2) getProvider();
+        assertTrue(primaryContactsProvider.areContactWritesEnabled());
+    }
+
+    public void testCloneContactsProviderInsert() {
+        Uri resultUri =
+                mCloneContactsActor.resolver.insert(ContactsContract.RawContacts.CONTENT_URI,
+                        getSampleContentValues());
+
+        // Here we expect a fakeUri returned to fail silently
+        Uri expectedUri = ContactsContract.RawContacts.CONTENT_URI.buildUpon()
+                .appendPath("0")
+                .build();
+        assertUriEquals(expectedUri, resultUri);
+        assertContactsProviderEmpty(mCloneContactsActor);
+    }
+
+    public void testPrimaryContactsProviderInsert() {
+        ContentValues inputContentValues = getSampleContentValues();
+        long rawContactId = insertRawContactsThroughPrimaryProvider(inputContentValues);
+        Cursor cursor = mActor.resolver.query(ContentUris.withAppendedId(
+                ContactsContract.RawContacts.CONTENT_URI, rawContactId),
+                null /* projection */, null /* queryArgs */, null /* cancellationSignal */);
+        assertNotNull(cursor);
+        assertEquals(1, cursor.getCount());
+        assertTrue(cursor.moveToFirst());
+        assertEquals(rawContactId,
+                cursor.getLong(cursor.getColumnIndex(ContactsContract.RawContacts._ID)));
+        assertEqualContentValues(inputContentValues, cursor);
+    }
+
+    public void testCloneContactsProviderUpdate() {
+        // Insert contact through the primary clone provider
+        ContentValues inputContentValues = getSampleContentValues();
+        long rawContactId = insertRawContactsThroughPrimaryProvider(inputContentValues);
+
+        // Update display name in the input content values
+        ContentValues updatedContentValues = getSampleContentValues();
+        updatedContentValues.put(ContactsContract.RawContacts.STARRED,
+                "0");
+        updatedContentValues.put(ContactsContract.RawContacts.CUSTOM_RINGTONE,
+                "beethoven5");
+
+        // Call clone contacts provider update method to update the raw contact inserted earlier
+        int updateResult = mCloneContactsActor.resolver.update(
+                ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI, rawContactId),
+                updatedContentValues, null /* extras */);
+
+        // Check results, no rows should have been affected
+        assertEquals(0, updateResult);
+
+        // Check values associated with rawContactId by querying the database
+        Cursor cursor = mActor.resolver.query(ContentUris.withAppendedId(
+                        ContactsContract.RawContacts.CONTENT_URI, rawContactId),
+                null /* projection */, null /* queryArgs */, null /* cancellationSignal */);
+        assertNotNull(cursor);
+        assertEquals(1, cursor.getCount());
+        assertTrue(cursor.moveToFirst());
+        assertEqualContentValues(inputContentValues, cursor);
+    }
+
+    public void testCloneContactsProviderDelete() {
+        // Insert contact through the primary clone provider
+        ContentValues inputContentValues = getSampleContentValues();
+        long rawContactId = insertRawContactsThroughPrimaryProvider(inputContentValues);
+
+        // Delete the inserted row through clone provider
+        int deleteResult = mCloneContactsActor.resolver.delete(
+                ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI, rawContactId),
+                null);
+
+        // Check results, no rows should have been affected
+        assertEquals(0, deleteResult);
+
+        // Check that contact is present in the primary CP2 database
+        Cursor cursor = mActor.resolver.query(ContentUris.withAppendedId(
+                        ContactsContract.RawContacts.CONTENT_URI, rawContactId),
+                null /* projection */, null /* queryArgs */, null /* cancellationSignal */);
+        assertNotNull(cursor);
+        assertEquals(1, cursor.getCount());
+        assertTrue(cursor.moveToFirst());
+        assertEqualContentValues(inputContentValues, cursor);
+    }
+
+    public void testCloneContactsProviderBulkInsert() {
+        int bulkInsertResult =
+                mCloneContactsActor.resolver.bulkInsert(ContactsContract.RawContacts.CONTENT_URI,
+                new ContentValues[]{ getSampleContentValues() });
+
+        // Check results, no rows should have been affected
+        assertEquals(0, bulkInsertResult);
+        assertContactsProviderEmpty(mCloneContactsActor);
+    }
+
+    public void testCloneContactsApplyBatch()
+            throws RemoteException, OperationApplicationException {
+        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
+
+        ops.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
+                .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null /* value */)
+                .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null /* value */).build());
+
+        // Phone Number
+        ops.add(ContentProviderOperation
+                .newInsert(ContactsContract.Data.CONTENT_URI)
+                .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
+                .withValue(ContactsContract.Data.MIMETYPE,
+                        ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
+                .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, "7XXXXXXXXXX")
+                .withValue(ContactsContract.Data.MIMETYPE,
+                        ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
+                .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, "1").build());
+
+        // Display name/Contact name
+        ops.add(ContentProviderOperation
+                .newInsert(ContactsContract.Data.CONTENT_URI)
+                .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
+                .withValue(ContactsContract.Data.MIMETYPE,
+                        ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
+                .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, "Name")
+                .build());
+
+        // Check results, fake uris should be returned for each of the insert operation
+        ContentProviderResult[] res = mCloneContactsActor.resolver.applyBatch(
+                    ContactsContract.AUTHORITY, ops);
+        assertRejectedApplyBatchResults(res, ops);
+
+        // No contacts should be present in both clone and primary providers
+        assertContactsProviderEmpty(mCloneContactsActor);
+        assertContactsProviderEmpty(mActor);
+    }
+
+    public void testCloneContactsCallOperation() {
+        // Query Account Operation
+        Bundle response = mCloneContactsActor.resolver.call(ContactsContract.AUTHORITY_URI,
+                ContactsContract.Settings.QUERY_DEFAULT_ACCOUNT_METHOD, null /* arg */,
+                null /* extras */);
+        assertNotNull(response);
+        assertEquals(Bundle.EMPTY, response);
+
+        // Set account operation
+        Bundle bundle = new Bundle();
+        bundle.putString(ContactsContract.Settings.ACCOUNT_NAME, "test@test.com");
+        bundle.putString(ContactsContract.Settings.ACCOUNT_TYPE, "test.com");
+        Bundle setAccountResponse =
+                mCloneContactsActor.resolver.call(ContactsContract.AUTHORITY_URI,
+                ContactsContract.Settings.SET_DEFAULT_ACCOUNT_METHOD, null /* arg */, bundle);
+        assertNotNull(setAccountResponse);
+        assertEquals(Bundle.EMPTY, response);
+
+        // Authorization URI
+        Uri testUri = ContentUris.withAppendedId(ContactsContract.Contacts.CONTENT_URI, 1);
+        final Bundle uriBundle = new Bundle();
+        uriBundle.putParcelable(ContactsContract.Authorization.KEY_URI_TO_AUTHORIZE, testUri);
+        final Bundle authResponse = mCloneContactsActor.resolver.call(
+                ContactsContract.AUTHORITY_URI,
+                ContactsContract.Authorization.AUTHORIZATION_METHOD,
+                null /* arg */,
+                uriBundle);
+        assertNotNull(authResponse);
+        assertEquals(Bundle.EMPTY, authResponse);
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/ContactsActor.java b/tests/src/com/android/providers/contacts/ContactsActor.java
index 639380fb..0d7d9b3b 100644
--- a/tests/src/com/android/providers/contacts/ContactsActor.java
+++ b/tests/src/com/android/providers/contacts/ContactsActor.java
@@ -16,6 +16,10 @@
 
 package com.android.providers.contacts;
 
+import static android.content.pm.UserProperties.SHOW_IN_LAUNCHER_WITH_PARENT;
+import static com.android.providers.contacts.ContactsActor.MockUserManager.CLONE_PROFILE_USER;
+import static com.android.providers.contacts.ContactsActor.MockUserManager.PRIMARY_USER;
+
 import static org.mockito.Mockito.when;
 
 import android.accounts.Account;
@@ -172,6 +176,8 @@ public class ContactsActor {
         public static final UserInfo CORP_USER = createUserInfo("corp", 10, 0,
                 UserInfo.FLAG_MANAGED_PROFILE);
         public static final UserInfo SECONDARY_USER = createUserInfo("2nd", 11, 11, 0);
+        public static final UserInfo CLONE_PROFILE_USER = createUserInfo("clone", 12, 0,
+                UserInfo.FLAG_PROFILE);
 
         /** "My" user.  Set it to change the current user. */
         public int myUser = DEFAULT_USER_ID;
@@ -258,6 +264,13 @@ public class ContactsActor {
 
         @Override
         public UserProperties getUserProperties(@NonNull UserHandle userHandle) {
+            if (CLONE_PROFILE_USER.getUserHandle().equals(userHandle)) {
+                return new UserProperties.Builder()
+                        .setUseParentsContacts(true)
+                        .setShowInLauncher(SHOW_IN_LAUNCHER_WITH_PARENT)
+                        .setStartWithParent(true)
+                        .build();
+            }
             return new UserProperties.Builder().build();
         }
     }
@@ -418,6 +431,15 @@ public class ContactsActor {
             }
 
             @Override
+            public UserHandle getUser() {
+                if (mockUserManager != null &&
+                        mockUserManager.getProcessUserId() == CLONE_PROFILE_USER.id) {
+                    return CLONE_PROFILE_USER.getUserHandle();
+                }
+                return PRIMARY_USER.getUserHandle();
+            }
+
+            @Override
             public void sendBroadcast(Intent intent, String receiverPermission) {
                 // Ignore.
             }
diff --git a/tests/src/com/android/providers/contacts/ContactsProvider2Test.java b/tests/src/com/android/providers/contacts/ContactsProvider2Test.java
index 09ea19fc..b625ac4a 100644
--- a/tests/src/com/android/providers/contacts/ContactsProvider2Test.java
+++ b/tests/src/com/android/providers/contacts/ContactsProvider2Test.java
@@ -9908,24 +9908,4 @@ public class ContactsProvider2Test extends BaseContactsProvider2Test {
         }
         return false;
     }
-
-
-    /**
-     * Asserts the equality of two Uri objects, ignoring the order of the query parameters.
-     */
-    public static void assertUriEquals(Uri expected, Uri actual) {
-        assertEquals(expected.getScheme(), actual.getScheme());
-        assertEquals(expected.getAuthority(), actual.getAuthority());
-        assertEquals(expected.getPath(), actual.getPath());
-        assertEquals(expected.getFragment(), actual.getFragment());
-        Set<String> expectedParameterNames = expected.getQueryParameterNames();
-        Set<String> actualParameterNames = actual.getQueryParameterNames();
-        assertEquals(expectedParameterNames.size(), actualParameterNames.size());
-        assertTrue(expectedParameterNames.containsAll(actualParameterNames));
-        for (String parameterName : expectedParameterNames) {
-            assertEquals(expected.getQueryParameter(parameterName),
-                    actual.getQueryParameter(parameterName));
-        }
-
-    }
 }
diff --git a/tests/src/com/android/providers/contacts/util/UserUtilsTest.java b/tests/src/com/android/providers/contacts/util/UserUtilsTest.java
index 93613cf5..072df377 100644
--- a/tests/src/com/android/providers/contacts/util/UserUtilsTest.java
+++ b/tests/src/com/android/providers/contacts/util/UserUtilsTest.java
@@ -77,5 +77,38 @@ public class UserUtilsTest extends FixedAndroidTestCase {
 
         um.myUser = MockUserManager.SECONDARY_USER.id;
         assertEquals(-1, UserUtils.getCorpUserId(c));
+
+        // Primary + clone + corp
+        um.setUsers(MockUserManager.PRIMARY_USER, MockUserManager.CLONE_PROFILE_USER,
+                MockUserManager.CORP_USER);
+
+        um.myUser = MockUserManager.PRIMARY_USER.id;
+        assertEquals(MockUserManager.CORP_USER.id, UserUtils.getCorpUserId(c));
+
+        um.myUser = MockUserManager.CLONE_PROFILE_USER.id;
+        assertEquals(-1, UserUtils.getCorpUserId(c));
+
+        um.myUser = MockUserManager.CORP_USER.id;
+        assertEquals(-1, UserUtils.getCorpUserId(c));
+    }
+
+    public void testShouldUseParentsContacts() {
+        final Context c = mActor.getProviderContext();
+        final MockUserManager um = mActor.mockUserManager;
+
+        um.setUsers(MockUserManager.PRIMARY_USER, MockUserManager.SECONDARY_USER,
+                MockUserManager.CLONE_PROFILE_USER, MockUserManager.CORP_USER);
+
+        um.myUser = MockUserManager.PRIMARY_USER.id;
+        assertFalse(UserUtils.shouldUseParentsContacts(c));
+
+        um.myUser = MockUserManager.SECONDARY_USER.id;
+        assertFalse(UserUtils.shouldUseParentsContacts(c));
+
+        um.myUser = MockUserManager.CORP_USER.id;
+        assertFalse(UserUtils.shouldUseParentsContacts(c));
+
+        um.myUser = MockUserManager.CLONE_PROFILE_USER.id;
+        assertTrue(UserUtils.shouldUseParentsContacts(c));
     }
 }