1 /* 2 * Copyright (C) 2011 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.editor; 18 19 import android.test.AndroidTestCase; 20 import android.test.MoreAsserts; 21 import android.test.suitebuilder.annotation.SmallTest; 22 23 import com.android.contacts.common.model.account.AccountType; 24 import com.android.contacts.common.model.account.AccountWithDataSet; 25 import com.android.contacts.tests.mocks.MockAccountTypeManager; 26 import com.google.common.collect.Sets; 27 28 import java.util.Collection; 29 import java.util.Set; 30 31 /** 32 * Test case for {@link ContactEditorUtils}. 33 * 34 * adb shell am instrument -w -e class com.android.contacts.editor.ContactEditorUtilsTest \ 35 com.android.contacts.tests/android.test.InstrumentationTestRunner 36 */ 37 @SmallTest 38 public class ContactEditorUtilsTest extends AndroidTestCase { 39 private MockAccountTypeManager mAccountTypes; 40 private ContactEditorUtils mTarget; 41 42 private static final MockAccountType TYPE1 = new MockAccountType("type1", null, true); 43 private static final MockAccountType TYPE2 = new MockAccountType("type2", null, true); 44 private static final MockAccountType TYPE2EX = new MockAccountType("type2", "ext", true); 45 46 // Only type 3 is "readonly". 47 private static final MockAccountType TYPE3 = new MockAccountType("type3", null, false); 48 49 private static final AccountWithDataSet ACCOUNT_1_A = new AccountWithDataSet( 50 "a", TYPE1.accountType, TYPE1.dataSet); 51 private static final AccountWithDataSet ACCOUNT_1_B = new AccountWithDataSet( 52 "b", TYPE1.accountType, TYPE1.dataSet); 53 54 private static final AccountWithDataSet ACCOUNT_2_A = new AccountWithDataSet( 55 "a", TYPE2.accountType, TYPE2.dataSet); 56 private static final AccountWithDataSet ACCOUNT_2EX_A = new AccountWithDataSet( 57 "a", TYPE2EX.accountType, TYPE2EX.dataSet); 58 59 private static final AccountWithDataSet ACCOUNT_3_C = new AccountWithDataSet( 60 "c", TYPE3.accountType, TYPE3.dataSet); 61 62 @Override 63 protected void setUp() throws Exception { 64 // Initialize with 0 types, 0 accounts. 65 mAccountTypes = new MockAccountTypeManager(new AccountType[] {}, 66 new AccountWithDataSet[] {}); 67 mTarget = new ContactEditorUtils(getContext(), mAccountTypes); 68 69 // Clear the preferences. 70 mTarget.cleanupForTest(); 71 } 72 73 private void setAccountTypes(AccountType... types) { 74 mAccountTypes.mTypes = types; 75 } 76 77 private void setAccounts(AccountWithDataSet... accounts) { 78 mAccountTypes.mAccounts = accounts; 79 } 80 81 public void testGetWritableAccountTypeStrings() { 82 String[] types; 83 84 // 0 writable types 85 setAccountTypes(); 86 87 types = mTarget.getWritableAccountTypeStrings(); 88 MoreAsserts.assertEquals(types, new String[0]); 89 90 // 1 writable type 91 setAccountTypes(TYPE1); 92 93 types = mTarget.getWritableAccountTypeStrings(); 94 MoreAsserts.assertEquals(Sets.newHashSet(TYPE1.accountType), Sets.newHashSet(types)); 95 96 // 2 writable types 97 setAccountTypes(TYPE1, TYPE2EX); 98 99 types = mTarget.getWritableAccountTypeStrings(); 100 MoreAsserts.assertEquals(Sets.newHashSet(TYPE1.accountType, TYPE2EX.accountType), 101 Sets.newHashSet(types)); 102 103 // 3 writable types + 1 readonly type 104 setAccountTypes(TYPE1, TYPE2, TYPE2EX, TYPE3); 105 106 types = mTarget.getWritableAccountTypeStrings(); 107 MoreAsserts.assertEquals( 108 Sets.newHashSet(TYPE1.accountType, TYPE2.accountType, TYPE2EX.accountType), 109 Sets.newHashSet(types)); 110 } 111 112 /** 113 * Test for 114 * - {@link ContactEditorUtils#saveDefaultAndAllAccounts} 115 * - {@link ContactEditorUtils#getDefaultAccount} 116 * - {@link ContactEditorUtils#getSavedAccounts()} 117 */ 118 public void testSaveDefaultAndAllAccounts() { 119 // Use these account types here. 120 setAccountTypes(TYPE1, TYPE2); 121 122 // If none has been saved, it should return an empty list. 123 assertEquals(0, mTarget.getSavedAccounts().size()); 124 125 // Save 0 accounts. 126 mAccountTypes.mAccounts = new AccountWithDataSet[]{}; 127 mTarget.saveDefaultAndAllAccounts(null); 128 assertNull(mTarget.getDefaultAccount()); 129 MoreAsserts.assertEquals( 130 Sets.newHashSet(mAccountTypes.mAccounts), 131 toSet(mTarget.getSavedAccounts())); 132 133 // 1 account 134 mAccountTypes.mAccounts = new AccountWithDataSet[]{ACCOUNT_1_A}; 135 mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A); 136 assertEquals(ACCOUNT_1_A, mTarget.getDefaultAccount()); 137 MoreAsserts.assertEquals( 138 Sets.newHashSet(mAccountTypes.mAccounts), 139 toSet(mTarget.getSavedAccounts())); 140 141 // 2 accounts 142 mAccountTypes.mAccounts = new AccountWithDataSet[]{ACCOUNT_1_A, ACCOUNT_1_B}; 143 mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_B); 144 assertEquals(ACCOUNT_1_B, mTarget.getDefaultAccount()); 145 MoreAsserts.assertEquals( 146 Sets.newHashSet(mAccountTypes.mAccounts), 147 toSet(mTarget.getSavedAccounts())); 148 149 // 2 accounts, and save null as the default. Even though there are accounts, the saved 150 // account list should be empty in this case. 151 mTarget.saveDefaultAndAllAccounts(null); 152 assertNull(mTarget.getDefaultAccount()); 153 assertEquals(0, mTarget.getSavedAccounts().size()); 154 } 155 156 public void testIsAccountValid() { 157 // Use these account types here. 158 setAccountTypes(TYPE1, TYPE2); 159 160 // 0 accounts 161 mAccountTypes.mAccounts = new AccountWithDataSet[]{}; 162 assertFalse(mTarget.isValidAccount(ACCOUNT_1_A)); 163 assertTrue(mTarget.isValidAccount(null)); // null is always valid 164 165 // 2 accounts 166 mAccountTypes.mAccounts = new AccountWithDataSet[]{ACCOUNT_1_A, ACCOUNT_2_A}; 167 assertTrue(mTarget.isValidAccount(ACCOUNT_1_A)); 168 assertTrue(mTarget.isValidAccount(ACCOUNT_2_A)); 169 assertFalse(mTarget.isValidAccount(ACCOUNT_2EX_A)); 170 assertTrue(mTarget.isValidAccount(null)); // null is always valid 171 } 172 173 /** 174 * Tests for {@link ContactEditorUtils#shouldShowAccountChangedNotification()}, starting with 175 * 0 accounts. 176 */ 177 public void testShouldShowAccountChangedNotification_0Accounts() { 178 // There's always at least one writable type... 179 setAccountTypes(TYPE1); 180 181 // First launch -- always true. 182 assertTrue(mTarget.shouldShowAccountChangedNotification()); 183 184 // We show the notification here, and user clicked "add account" 185 setAccounts(ACCOUNT_1_A); 186 187 // Now we open the contact editor with the new account. 188 189 // When closing the editor, we save the default account. 190 mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A); 191 192 // Next time the user creates a contact, we don't show the notification. 193 assertFalse(mTarget.shouldShowAccountChangedNotification()); 194 195 // User added a new writable account, ACCOUNT_1_B. 196 setAccounts(ACCOUNT_1_A, ACCOUNT_1_B); 197 198 // Now we show the notification again. 199 assertTrue(mTarget.shouldShowAccountChangedNotification()); 200 201 // User saved a new contact. We update the account list and the default account. 202 mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_B); 203 204 // User created another contact. Now we don't show the notification. 205 assertFalse(mTarget.shouldShowAccountChangedNotification()); 206 207 // User installed a new contact sync adapter... 208 209 // Added a new account type: TYPE2, and the TYPE2EX extension. 210 setAccountTypes(TYPE1, TYPE2, TYPE2EX); 211 // Add new accounts: ACCOUNT_2_A, ACCOUNT_2EX_A. 212 setAccounts(ACCOUNT_1_A, ACCOUNT_1_B, ACCOUNT_2_A, ACCOUNT_2EX_A); 213 214 // New account means another notification. 215 assertTrue(mTarget.shouldShowAccountChangedNotification()); 216 217 // User saves a new contact, with a different default account. 218 mTarget.saveDefaultAndAllAccounts(ACCOUNT_2_A); 219 220 // Next time user creates a contact, no notification. 221 assertFalse(mTarget.shouldShowAccountChangedNotification()); 222 223 // Remove ACCOUNT_2EX_A. 224 setAccountTypes(TYPE1, TYPE2, TYPE2EX); 225 setAccounts(ACCOUNT_1_A, ACCOUNT_1_B, ACCOUNT_2_A); 226 227 // ACCOUNT_2EX_A was not default, so no notification either. 228 assertFalse(mTarget.shouldShowAccountChangedNotification()); 229 230 // Remove ACCOUNT_1_B, which is default. 231 setAccountTypes(TYPE1, TYPE2, TYPE2EX); 232 setAccounts(ACCOUNT_1_A, ACCOUNT_1_B); 233 234 // Now we show the notification. 235 assertTrue(mTarget.shouldShowAccountChangedNotification()); 236 } 237 238 /** 239 * Tests for {@link ContactEditorUtils#shouldShowAccountChangedNotification()}, starting with 240 * 1 accounts. 241 */ 242 public void testShouldShowAccountChangedNotification_1Account() { 243 setAccountTypes(TYPE1, TYPE2); 244 setAccounts(ACCOUNT_1_A); 245 246 // First launch -- always true. 247 assertTrue(mTarget.shouldShowAccountChangedNotification()); 248 249 // User saves a new contact. 250 mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A); 251 252 // Next time, no notification. 253 assertFalse(mTarget.shouldShowAccountChangedNotification()); 254 255 // The rest is the same... 256 } 257 258 /** 259 * Tests for {@link ContactEditorUtils#shouldShowAccountChangedNotification()}, starting with 260 * 0 accounts, and the user selected "local only". 261 */ 262 public void testShouldShowAccountChangedNotification_0Account_localOnly() { 263 // There's always at least one writable type... 264 setAccountTypes(TYPE1); 265 266 // First launch -- always true. 267 assertTrue(mTarget.shouldShowAccountChangedNotification()); 268 269 // We show the notification here, and user clicked "keep local" and saved an contact. 270 mTarget.saveDefaultAndAllAccounts(null); 271 272 // Now there are no accounts, and default account is null. 273 274 // The user created another contact, but this we shouldn't show the notification. 275 assertFalse(mTarget.shouldShowAccountChangedNotification()); 276 } 277 278 public void testShouldShowAccountChangedNotification_sanity_check() { 279 // Prepare 1 account and save it as the default. 280 setAccountTypes(TYPE1); 281 setAccounts(ACCOUNT_1_A); 282 283 mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A); 284 285 // Right after a save, the dialog shouldn't show up. 286 assertFalse(mTarget.shouldShowAccountChangedNotification()); 287 288 // Remove the default account to emulate broken preferences. 289 mTarget.removeDefaultAccountForTest(); 290 assertTrue(mTarget.shouldShowAccountChangedNotification()); 291 } 292 293 private static <T> Set<T> toSet(Collection<T> collection) { 294 Set<T> ret = Sets.newHashSet(); 295 ret.addAll(collection); 296 return ret; 297 } 298 299 private static class MockAccountType extends AccountType { 300 private boolean mAreContactsWritable; 301 302 public MockAccountType(String accountType, String dataSet, boolean areContactsWritable) { 303 this.accountType = accountType; 304 this.dataSet = dataSet; 305 mAreContactsWritable = areContactsWritable; 306 } 307 308 @Override 309 public boolean areContactsWritable() { 310 return mAreContactsWritable; 311 } 312 313 @Override 314 public boolean isGroupMembershipEditable() { 315 return true; 316 } 317 } 318 } 319
