• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2009 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.contacts.common;
18 
19 import android.content.ContentProviderOperation;
20 import android.content.ContentValues;
21 import android.content.Context;
22 import android.net.Uri;
23 import android.provider.BaseColumns;
24 import android.provider.ContactsContract.AggregationExceptions;
25 import android.provider.ContactsContract.CommonDataKinds.Email;
26 import android.provider.ContactsContract.CommonDataKinds.Phone;
27 import android.provider.ContactsContract.Data;
28 import android.provider.ContactsContract.RawContacts;
29 import android.test.AndroidTestCase;
30 import android.test.suitebuilder.annotation.LargeTest;
31 
32 import com.android.contacts.common.RawContactModifierTests.MockContactsSource;
33 import com.android.contacts.common.compat.CompatUtils;
34 import com.android.contacts.common.model.CPOWrapper;
35 import com.android.contacts.common.model.RawContact;
36 import com.android.contacts.common.model.RawContactDelta;
37 import com.android.contacts.common.model.ValuesDelta;
38 import com.android.contacts.common.model.RawContactDeltaList;
39 import com.android.contacts.common.model.RawContactModifier;
40 import com.android.contacts.common.model.account.AccountType;
41 import com.google.common.collect.Lists;
42 
43 
44 import java.lang.reflect.Field;
45 import java.util.ArrayList;
46 import java.util.Collections;
47 
48 /**
49  * Tests for {@link RawContactDeltaList} which focus on "diff" operations that should
50  * create {@link AggregationExceptions} in certain cases.
51  */
52 @LargeTest
53 public class RawContactDeltaListTests extends AndroidTestCase {
54     public static final String TAG = RawContactDeltaListTests.class.getSimpleName();
55 
56     // From android.content.ContentProviderOperation
57     public static final int TYPE_INSERT = 1;
58     public static final int TYPE_UPDATE = 2;
59     public static final int TYPE_DELETE = 3;
60     public static final int TYPE_ASSERT = 4;
61 
62     private static final long CONTACT_FIRST = 1;
63     private static final long CONTACT_SECOND = 2;
64 
65     public static final long CONTACT_BOB = 10;
66     public static final long CONTACT_MARY = 11;
67 
68     public static final long PHONE_RED = 20;
69     public static final long PHONE_GREEN = 21;
70     public static final long PHONE_BLUE = 22;
71 
72     public static final long EMAIL_YELLOW = 25;
73 
74     public static final long VER_FIRST = 100;
75     public static final long VER_SECOND = 200;
76 
77     public static final String TEST_PHONE = "555-1212";
78     public static final String TEST_ACCOUNT = "org.example.test";
79 
RawContactDeltaListTests()80     public RawContactDeltaListTests() {
81         super();
82     }
83 
84     @Override
setUp()85     public void setUp() {
86         mContext = getContext();
87     }
88 
89     /**
90      * Build a {@link AccountType} that has various odd constraints for
91      * testing purposes.
92      */
getAccountType()93     protected AccountType getAccountType() {
94         return new MockContactsSource();
95     }
96 
getValues(ContentProviderOperation operation)97     static ContentValues getValues(ContentProviderOperation operation)
98             throws NoSuchFieldException, IllegalAccessException {
99         final Field field = ContentProviderOperation.class.getDeclaredField("mValues");
100         field.setAccessible(true);
101         return (ContentValues) field.get(operation);
102     }
103 
getUpdate(Context context, long rawContactId)104     static RawContactDelta getUpdate(Context context, long rawContactId) {
105         final RawContact before = RawContactDeltaTests.getRawContact(context, rawContactId,
106                 RawContactDeltaTests.TEST_PHONE_ID);
107         return RawContactDelta.fromBefore(before);
108     }
109 
getInsert()110     static RawContactDelta getInsert() {
111         final ContentValues after = new ContentValues();
112         after.put(RawContacts.ACCOUNT_NAME, RawContactDeltaTests.TEST_ACCOUNT_NAME);
113         after.put(RawContacts.SEND_TO_VOICEMAIL, 1);
114 
115         final ValuesDelta values = ValuesDelta.fromAfter(after);
116         return new RawContactDelta(values);
117     }
118 
buildSet(RawContactDelta... deltas)119     static RawContactDeltaList buildSet(RawContactDelta... deltas) {
120         final RawContactDeltaList set = new RawContactDeltaList();
121         Collections.addAll(set, deltas);
122         return set;
123     }
124 
buildBeforeEntity(Context context, long rawContactId, long version, ContentValues... entries)125     static RawContactDelta buildBeforeEntity(Context context, long rawContactId, long version,
126             ContentValues... entries) {
127         // Build an existing contact read from database
128         final ContentValues contact = new ContentValues();
129         contact.put(RawContacts.VERSION, version);
130         contact.put(RawContacts._ID, rawContactId);
131         final RawContact before = new RawContact(contact);
132         for (ContentValues entry : entries) {
133             before.addDataItemValues(entry);
134         }
135         return RawContactDelta.fromBefore(before);
136     }
137 
buildAfterEntity(ContentValues... entries)138     static RawContactDelta buildAfterEntity(ContentValues... entries) {
139         // Build an existing contact read from database
140         final ContentValues contact = new ContentValues();
141         contact.put(RawContacts.ACCOUNT_TYPE, TEST_ACCOUNT);
142         final RawContactDelta after = new RawContactDelta(ValuesDelta.fromAfter(contact));
143         for (ContentValues entry : entries) {
144             after.addEntry(ValuesDelta.fromAfter(entry));
145         }
146         return after;
147     }
148 
buildPhone(long phoneId)149     static ContentValues buildPhone(long phoneId) {
150         return buildPhone(phoneId, Long.toString(phoneId));
151     }
152 
buildPhone(long phoneId, String value)153     static ContentValues buildPhone(long phoneId, String value) {
154         final ContentValues values = new ContentValues();
155         values.put(Data._ID, phoneId);
156         values.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
157         values.put(Phone.NUMBER, value);
158         values.put(Phone.TYPE, Phone.TYPE_HOME);
159         return values;
160     }
161 
buildEmail(long emailId)162     static ContentValues buildEmail(long emailId) {
163         final ContentValues values = new ContentValues();
164         values.put(Data._ID, emailId);
165         values.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
166         values.put(Email.DATA, Long.toString(emailId));
167         values.put(Email.TYPE, Email.TYPE_HOME);
168         return values;
169     }
170 
insertPhone(RawContactDeltaList set, long rawContactId, ContentValues values)171     static void insertPhone(RawContactDeltaList set, long rawContactId, ContentValues values) {
172         final RawContactDelta match = set.getByRawContactId(rawContactId);
173         match.addEntry(ValuesDelta.fromAfter(values));
174     }
175 
getPhone(RawContactDeltaList set, long rawContactId, long dataId)176     static ValuesDelta getPhone(RawContactDeltaList set, long rawContactId, long dataId) {
177         final RawContactDelta match = set.getByRawContactId(rawContactId);
178         return match.getEntry(dataId);
179     }
180 
assertDiffPattern(RawContactDelta delta, CPOWrapper... pattern)181     static void assertDiffPattern(RawContactDelta delta, CPOWrapper... pattern) {
182         final ArrayList<CPOWrapper> diff = Lists.newArrayList();
183         delta.buildAssertWrapper(diff);
184         delta.buildDiffWrapper(diff);
185         assertDiffPattern(diff, pattern);
186     }
187 
assertDiffPattern(RawContactDeltaList set, CPOWrapper... pattern)188     static void assertDiffPattern(RawContactDeltaList set, CPOWrapper... pattern) {
189         assertDiffPattern(set.buildDiffWrapper(), pattern);
190     }
191 
assertDiffPattern(ArrayList<CPOWrapper> diff, CPOWrapper... pattern)192     static void assertDiffPattern(ArrayList<CPOWrapper> diff, CPOWrapper... pattern) {
193         assertEquals("Unexpected operations", pattern.length, diff.size());
194         for (int i = 0; i < pattern.length; i++) {
195             final CPOWrapper expected = pattern[i];
196             final CPOWrapper found = diff.get(i);
197 
198             assertEquals("Unexpected uri",
199                     expected.getOperation().getUri(), found.getOperation().getUri());
200 
201             final String expectedType = getTypeString(expected);
202             final String foundType = getTypeString(found);
203             assertEquals("Unexpected type", expectedType, foundType);
204 
205             if (CompatUtils.isDeleteCompat(expected)) continue;
206 
207             try {
208                 final ContentValues expectedValues = getValues(expected.getOperation());
209                 final ContentValues foundValues = getValues(found.getOperation());
210 
211                 expectedValues.remove(BaseColumns._ID);
212                 foundValues.remove(BaseColumns._ID);
213 
214                 assertEquals("Unexpected values", expectedValues, foundValues);
215             } catch (NoSuchFieldException e) {
216                 fail(e.toString());
217             } catch (IllegalAccessException e) {
218                 fail(e.toString());
219             }
220         }
221     }
222 
getTypeString(CPOWrapper cpoWrapper)223     static String getTypeString(CPOWrapper cpoWrapper) {
224         if (CompatUtils.isAssertQueryCompat(cpoWrapper)) {
225             return "TYPE_ASSERT";
226         } else if (CompatUtils.isInsertCompat(cpoWrapper)) {
227             return "TYPE_INSERT";
228         } else if (CompatUtils.isUpdateCompat(cpoWrapper)) {
229             return "TYPE_UPDATE";
230         } else if (CompatUtils.isDeleteCompat(cpoWrapper)) {
231             return "TYPE_DELETE";
232         }
233         return "TYPE_UNKNOWN";
234     }
235 
buildAssertVersion(long version)236     static CPOWrapper buildAssertVersion(long version) {
237         final ContentValues values = new ContentValues();
238         values.put(RawContacts.VERSION, version);
239         return buildCPOWrapper(RawContacts.CONTENT_URI, TYPE_ASSERT, values);
240     }
241 
buildAggregationModeUpdate(int mode)242     static CPOWrapper buildAggregationModeUpdate(int mode) {
243         final ContentValues values = new ContentValues();
244         values.put(RawContacts.AGGREGATION_MODE, mode);
245         return buildCPOWrapper(RawContacts.CONTENT_URI, TYPE_UPDATE, values);
246     }
247 
buildUpdateAggregationSuspended()248     static CPOWrapper buildUpdateAggregationSuspended() {
249         return buildAggregationModeUpdate(RawContacts.AGGREGATION_MODE_SUSPENDED);
250     }
251 
buildUpdateAggregationDefault()252     static CPOWrapper buildUpdateAggregationDefault() {
253         return buildAggregationModeUpdate(RawContacts.AGGREGATION_MODE_DEFAULT);
254     }
255 
buildUpdateAggregationKeepTogether(long rawContactId)256     static CPOWrapper buildUpdateAggregationKeepTogether(long rawContactId) {
257         final ContentValues values = new ContentValues();
258         values.put(AggregationExceptions.RAW_CONTACT_ID1, rawContactId);
259         values.put(AggregationExceptions.TYPE, AggregationExceptions.TYPE_KEEP_TOGETHER);
260         return buildCPOWrapper(AggregationExceptions.CONTENT_URI, TYPE_UPDATE, values);
261     }
262 
buildDataInsert(ValuesDelta values, long rawContactId)263     static ContentValues buildDataInsert(ValuesDelta values, long rawContactId) {
264         final ContentValues insertValues = values.getCompleteValues();
265         insertValues.put(Data.RAW_CONTACT_ID, rawContactId);
266         return insertValues;
267     }
268 
buildDelete(Uri uri)269     static CPOWrapper buildDelete(Uri uri) {
270         return buildCPOWrapper(uri, TYPE_DELETE, (ContentValues) null);
271     }
272 
buildOper(Uri uri, int type, ValuesDelta values)273     static ContentProviderOperation buildOper(Uri uri, int type, ValuesDelta values) {
274         return buildOper(uri, type, values.getCompleteValues());
275     }
276 
buildOper(Uri uri, int type, ContentValues values)277     static ContentProviderOperation buildOper(Uri uri, int type, ContentValues values) {
278         switch (type) {
279             case TYPE_ASSERT:
280                 return ContentProviderOperation.newAssertQuery(uri).withValues(values).build();
281             case TYPE_INSERT:
282                 return ContentProviderOperation.newInsert(uri).withValues(values).build();
283             case TYPE_UPDATE:
284                 return ContentProviderOperation.newUpdate(uri).withValues(values).build();
285             case TYPE_DELETE:
286                 return ContentProviderOperation.newDelete(uri).build();
287         }
288         return null;
289     }
290 
buildCPOWrapper(Uri uri, int type, ContentValues values)291     static CPOWrapper buildCPOWrapper(Uri uri, int type, ContentValues values) {
292         if (type == TYPE_ASSERT || type == TYPE_INSERT || type == TYPE_UPDATE
293                 || type == TYPE_DELETE) {
294             return new CPOWrapper(buildOper(uri, type, values), type);
295         }
296         return null;
297     }
298 
getVersion(RawContactDeltaList set, Long rawContactId)299     static Long getVersion(RawContactDeltaList set, Long rawContactId) {
300         return set.getByRawContactId(rawContactId).getValues().getAsLong(RawContacts.VERSION);
301     }
302 
303     /**
304      * Count number of {@link AggregationExceptions} updates contained in the
305      * given list of {@link CPOWrapper}.
306      */
countExceptionUpdates(ArrayList<CPOWrapper> diff)307     static int countExceptionUpdates(ArrayList<CPOWrapper> diff) {
308         int updateCount = 0;
309         for (CPOWrapper cpoWrapper : diff) {
310             final ContentProviderOperation oper = cpoWrapper.getOperation();
311             if (AggregationExceptions.CONTENT_URI.equals(oper.getUri())
312                     && CompatUtils.isUpdateCompat(cpoWrapper)) {
313                 updateCount++;
314             }
315         }
316         return updateCount;
317     }
318 
testInsert()319     public void testInsert() {
320         final RawContactDelta insert = getInsert();
321         final RawContactDeltaList set = buildSet(insert);
322 
323         // Inserting single shouldn't create rules
324         final ArrayList<CPOWrapper> diff = set.buildDiffWrapper();
325         final int exceptionCount = countExceptionUpdates(diff);
326         assertEquals("Unexpected exception updates", 0, exceptionCount);
327     }
328 
testUpdateUpdate()329     public void testUpdateUpdate() {
330         final RawContactDelta updateFirst = getUpdate(mContext, CONTACT_FIRST);
331         final RawContactDelta updateSecond = getUpdate(mContext, CONTACT_SECOND);
332         final RawContactDeltaList set = buildSet(updateFirst, updateSecond);
333 
334         // Updating two existing shouldn't create rules
335         final ArrayList<CPOWrapper> diff = set.buildDiffWrapper();
336         final int exceptionCount = countExceptionUpdates(diff);
337         assertEquals("Unexpected exception updates", 0, exceptionCount);
338     }
339 
testUpdateInsert()340     public void testUpdateInsert() {
341         final RawContactDelta update = getUpdate(mContext, CONTACT_FIRST);
342         final RawContactDelta insert = getInsert();
343         final RawContactDeltaList set = buildSet(update, insert);
344 
345         // New insert should only create one rule
346         final ArrayList<CPOWrapper> diff = set.buildDiffWrapper();
347         final int exceptionCount = countExceptionUpdates(diff);
348         assertEquals("Unexpected exception updates", 1, exceptionCount);
349     }
350 
testInsertUpdateInsert()351     public void testInsertUpdateInsert() {
352         final RawContactDelta insertFirst = getInsert();
353         final RawContactDelta update = getUpdate(mContext, CONTACT_FIRST);
354         final RawContactDelta insertSecond = getInsert();
355         final RawContactDeltaList set = buildSet(insertFirst, update, insertSecond);
356 
357         // Two inserts should create two rules to bind against single existing
358         final ArrayList<CPOWrapper> diff = set.buildDiffWrapper();
359         final int exceptionCount = countExceptionUpdates(diff);
360         assertEquals("Unexpected exception updates", 2, exceptionCount);
361     }
362 
testInsertInsertInsert()363     public void testInsertInsertInsert() {
364         final RawContactDelta insertFirst = getInsert();
365         final RawContactDelta insertSecond = getInsert();
366         final RawContactDelta insertThird = getInsert();
367         final RawContactDeltaList set = buildSet(insertFirst, insertSecond, insertThird);
368 
369         // Three new inserts should create only two binding rules
370         final ArrayList<CPOWrapper> diff = set.buildDiffWrapper();
371         final int exceptionCount = countExceptionUpdates(diff);
372         assertEquals("Unexpected exception updates", 2, exceptionCount);
373     }
374 
testMergeDataRemoteInsert()375     public void testMergeDataRemoteInsert() {
376         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
377                 VER_FIRST, buildPhone(PHONE_RED)));
378         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
379                 VER_SECOND, buildPhone(PHONE_RED), buildPhone(PHONE_GREEN)));
380 
381         // Merge in second version, verify they match
382         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
383         assertEquals("Unexpected change when merging", second, merged);
384     }
385 
testMergeDataLocalUpdateRemoteInsert()386     public void testMergeDataLocalUpdateRemoteInsert() {
387         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
388                 VER_FIRST, buildPhone(PHONE_RED)));
389         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
390                 VER_SECOND, buildPhone(PHONE_RED), buildPhone(PHONE_GREEN)));
391 
392         // Change the local number to trigger update
393         final ValuesDelta phone = getPhone(first, CONTACT_BOB, PHONE_RED);
394         phone.put(Phone.NUMBER, TEST_PHONE);
395 
396         assertDiffPattern(first,
397                 buildAssertVersion(VER_FIRST),
398                 buildUpdateAggregationSuspended(),
399                 buildCPOWrapper(Data.CONTENT_URI, TYPE_UPDATE, phone.getAfter()),
400                 buildUpdateAggregationDefault());
401 
402         // Merge in the second version, verify diff matches
403         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
404         assertDiffPattern(merged,
405                 buildAssertVersion(VER_SECOND),
406                 buildUpdateAggregationSuspended(),
407                 buildCPOWrapper(Data.CONTENT_URI, TYPE_UPDATE, phone.getAfter()),
408                 buildUpdateAggregationDefault());
409     }
410 
testMergeDataLocalUpdateRemoteDelete()411     public void testMergeDataLocalUpdateRemoteDelete() {
412         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
413                 VER_FIRST, buildPhone(PHONE_RED)));
414         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
415                 VER_SECOND, buildPhone(PHONE_GREEN)));
416 
417         // Change the local number to trigger update
418         final ValuesDelta phone = getPhone(first, CONTACT_BOB, PHONE_RED);
419         phone.put(Phone.NUMBER, TEST_PHONE);
420 
421         assertDiffPattern(first,
422                 buildAssertVersion(VER_FIRST),
423                 buildUpdateAggregationSuspended(),
424                 buildCPOWrapper(Data.CONTENT_URI, TYPE_UPDATE, phone.getAfter()),
425                 buildUpdateAggregationDefault());
426 
427         // Merge in the second version, verify that our update changed to
428         // insert, since RED was deleted on remote side
429         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
430         assertDiffPattern(merged,
431                 buildAssertVersion(VER_SECOND),
432                 buildUpdateAggregationSuspended(),
433                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, buildDataInsert(phone, CONTACT_BOB)),
434                 buildUpdateAggregationDefault());
435     }
436 
testMergeDataLocalDeleteRemoteUpdate()437     public void testMergeDataLocalDeleteRemoteUpdate() {
438         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
439                 VER_FIRST, buildPhone(PHONE_RED)));
440         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
441                 VER_SECOND, buildPhone(PHONE_RED, TEST_PHONE)));
442 
443         // Delete phone locally
444         final ValuesDelta phone = getPhone(first, CONTACT_BOB, PHONE_RED);
445         phone.markDeleted();
446 
447         assertDiffPattern(first,
448                 buildAssertVersion(VER_FIRST),
449                 buildUpdateAggregationSuspended(),
450                 buildDelete(Data.CONTENT_URI),
451                 buildUpdateAggregationDefault());
452 
453         // Merge in the second version, verify that our delete remains
454         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
455         assertDiffPattern(merged,
456                 buildAssertVersion(VER_SECOND),
457                 buildUpdateAggregationSuspended(),
458                 buildDelete(Data.CONTENT_URI),
459                 buildUpdateAggregationDefault());
460     }
461 
testMergeDataLocalInsertRemoteInsert()462     public void testMergeDataLocalInsertRemoteInsert() {
463         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
464                 VER_FIRST, buildPhone(PHONE_RED)));
465         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
466                 VER_SECOND, buildPhone(PHONE_RED), buildPhone(PHONE_GREEN)));
467 
468         // Insert new phone locally
469         final ValuesDelta bluePhone = ValuesDelta.fromAfter(buildPhone(PHONE_BLUE));
470         first.getByRawContactId(CONTACT_BOB).addEntry(bluePhone);
471         assertDiffPattern(first,
472                 buildAssertVersion(VER_FIRST),
473                 buildUpdateAggregationSuspended(),
474                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, buildDataInsert(bluePhone, CONTACT_BOB)),
475                 buildUpdateAggregationDefault());
476 
477         // Merge in the second version, verify that our insert remains
478         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
479         assertDiffPattern(merged,
480                 buildAssertVersion(VER_SECOND),
481                 buildUpdateAggregationSuspended(),
482                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, buildDataInsert(bluePhone, CONTACT_BOB)),
483                 buildUpdateAggregationDefault());
484     }
485 
testMergeRawContactLocalInsertRemoteInsert()486     public void testMergeRawContactLocalInsertRemoteInsert() {
487         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
488                 VER_FIRST, buildPhone(PHONE_RED)));
489         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
490                 VER_SECOND, buildPhone(PHONE_RED)), buildBeforeEntity(mContext, CONTACT_MARY,
491                         VER_SECOND, buildPhone(PHONE_RED)));
492 
493         // Add new contact locally, should remain insert
494         final ContentValues joePhoneInsert = buildPhone(PHONE_BLUE);
495         final RawContactDelta joeContact = buildAfterEntity(joePhoneInsert);
496         final ContentValues joeContactInsert = joeContact.getValues().getCompleteValues();
497         joeContactInsert.put(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_SUSPENDED);
498         first.add(joeContact);
499         assertDiffPattern(first,
500                 buildAssertVersion(VER_FIRST),
501                 buildCPOWrapper(RawContacts.CONTENT_URI, TYPE_INSERT, joeContactInsert),
502                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, joePhoneInsert),
503                 buildAggregationModeUpdate(RawContacts.AGGREGATION_MODE_DEFAULT),
504                 buildUpdateAggregationKeepTogether(CONTACT_BOB));
505 
506         // Merge in the second version, verify that our insert remains
507         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
508         assertDiffPattern(merged,
509                 buildAssertVersion(VER_SECOND),
510                 buildAssertVersion(VER_SECOND),
511                 buildCPOWrapper(RawContacts.CONTENT_URI, TYPE_INSERT, joeContactInsert),
512                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, joePhoneInsert),
513                 buildAggregationModeUpdate(RawContacts.AGGREGATION_MODE_DEFAULT),
514                 buildUpdateAggregationKeepTogether(CONTACT_BOB));
515     }
516 
testMergeRawContactLocalDeleteRemoteDelete()517     public void testMergeRawContactLocalDeleteRemoteDelete() {
518         final RawContactDeltaList first = buildSet(
519                 buildBeforeEntity(mContext, CONTACT_BOB, VER_FIRST, buildPhone(PHONE_RED)),
520                 buildBeforeEntity(mContext, CONTACT_MARY, VER_FIRST, buildPhone(PHONE_RED)));
521         final RawContactDeltaList second = buildSet(
522                 buildBeforeEntity(mContext, CONTACT_BOB, VER_SECOND, buildPhone(PHONE_RED)));
523 
524         // Remove contact locally
525         first.getByRawContactId(CONTACT_MARY).markDeleted();
526         assertDiffPattern(first,
527                 buildAssertVersion(VER_FIRST),
528                 buildAssertVersion(VER_FIRST),
529                 buildDelete(RawContacts.CONTENT_URI));
530 
531         // Merge in the second version, verify that our delete isn't needed
532         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
533         assertDiffPattern(merged);
534     }
535 
testMergeRawContactLocalUpdateRemoteDelete()536     public void testMergeRawContactLocalUpdateRemoteDelete() {
537         final RawContactDeltaList first = buildSet(
538                 buildBeforeEntity(mContext, CONTACT_BOB, VER_FIRST, buildPhone(PHONE_RED)),
539                 buildBeforeEntity(mContext, CONTACT_MARY, VER_FIRST, buildPhone(PHONE_RED)));
540         final RawContactDeltaList second = buildSet(
541                 buildBeforeEntity(mContext, CONTACT_BOB, VER_SECOND, buildPhone(PHONE_RED)));
542 
543         // Perform local update
544         final ValuesDelta phone = getPhone(first, CONTACT_MARY, PHONE_RED);
545         phone.put(Phone.NUMBER, TEST_PHONE);
546         assertDiffPattern(first,
547                 buildAssertVersion(VER_FIRST),
548                 buildAssertVersion(VER_FIRST),
549                 buildUpdateAggregationSuspended(),
550                 buildCPOWrapper(Data.CONTENT_URI, TYPE_UPDATE, phone.getAfter()),
551                 buildUpdateAggregationDefault());
552 
553         final ContentValues phoneInsert = phone.getCompleteValues();
554         final ContentValues contactInsert = first.getByRawContactId(CONTACT_MARY).getValues()
555                 .getCompleteValues();
556         contactInsert.put(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_SUSPENDED);
557 
558         // Merge and verify that update turned into insert
559         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
560         assertDiffPattern(merged,
561                 buildAssertVersion(VER_SECOND),
562                 buildCPOWrapper(RawContacts.CONTENT_URI, TYPE_INSERT, contactInsert),
563                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, phoneInsert),
564                 buildAggregationModeUpdate(RawContacts.AGGREGATION_MODE_DEFAULT),
565                 buildUpdateAggregationKeepTogether(CONTACT_BOB));
566     }
567 
testMergeUsesNewVersion()568     public void testMergeUsesNewVersion() {
569         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
570                 VER_FIRST, buildPhone(PHONE_RED)));
571         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
572                 VER_SECOND, buildPhone(PHONE_RED)));
573 
574         assertEquals((Long)VER_FIRST, getVersion(first, CONTACT_BOB));
575         assertEquals((Long)VER_SECOND, getVersion(second, CONTACT_BOB));
576 
577         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
578         assertEquals((Long)VER_SECOND, getVersion(merged, CONTACT_BOB));
579     }
580 
testMergeAfterEnsureAndTrim()581     public void testMergeAfterEnsureAndTrim() {
582         final RawContactDeltaList first = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
583                 VER_FIRST, buildEmail(EMAIL_YELLOW)));
584         final RawContactDeltaList second = buildSet(buildBeforeEntity(mContext, CONTACT_BOB,
585                 VER_SECOND, buildEmail(EMAIL_YELLOW)));
586 
587         // Ensure we have at least one phone
588         final AccountType source = getAccountType();
589         final RawContactDelta bobContact = first.getByRawContactId(CONTACT_BOB);
590         RawContactModifier.ensureKindExists(bobContact, source, Phone.CONTENT_ITEM_TYPE);
591         final ValuesDelta bobPhone = bobContact.getSuperPrimaryEntry(Phone.CONTENT_ITEM_TYPE, true);
592 
593         // Make sure the update would insert a row
594         assertDiffPattern(first,
595                 buildAssertVersion(VER_FIRST),
596                 buildUpdateAggregationSuspended(),
597                 buildCPOWrapper(Data.CONTENT_URI, TYPE_INSERT, buildDataInsert(bobPhone, CONTACT_BOB)),
598                 buildUpdateAggregationDefault());
599 
600         // Trim values and ensure that we don't insert things
601         RawContactModifier.trimEmpty(bobContact, source);
602         assertDiffPattern(first);
603 
604         // Now re-parent the change, which should remain no-op
605         final RawContactDeltaList merged = RawContactDeltaList.mergeAfter(second, first);
606         assertDiffPattern(merged);
607     }
608 }
609