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 17package com.android.email; 18 19import android.content.Context; 20import android.net.Uri; 21import android.test.ProviderTestCase2; 22 23import com.android.email.provider.ContentCache; 24import com.android.email.provider.EmailProvider; 25import com.android.email.provider.ProviderTestUtils; 26import com.android.emailcommon.provider.Account; 27import com.android.emailcommon.provider.EmailContent; 28import com.android.emailcommon.provider.EmailContent.Body; 29import com.android.emailcommon.provider.EmailContent.Message; 30import com.android.emailcommon.provider.HostAuth; 31import com.android.emailcommon.provider.Mailbox; 32 33import java.util.Locale; 34import java.util.concurrent.ExecutionException; 35 36/** 37 * Tests of the Controller class that depend on the underlying provider. 38 * 39 * NOTE: It would probably make sense to rewrite this using a MockProvider, instead of the 40 * ProviderTestCase (which is a real provider running on a temp database). This would be more of 41 * a true "unit test". 42 * 43 * You can run this entire test case with: 44 * runtest -c com.android.email.ControllerProviderOpsTests email 45 */ 46public class ControllerProviderOpsTests extends ProviderTestCase2<EmailProvider> { 47 48 private Context mProviderContext; 49 private Context mContext; 50 private TestController mTestController; 51 52 53 public ControllerProviderOpsTests() { 54 super(EmailProvider.class, EmailContent.AUTHORITY); 55 } 56 57 @Override 58 public void setUp() throws Exception { 59 super.setUp(); 60 mProviderContext = getMockContext(); 61 mContext = getContext(); 62 mTestController = new TestController(mProviderContext, mContext); 63 // Invalidate all caches, since we reset the database for each test 64 ContentCache.invalidateAllCaches(); 65 } 66 67 @Override 68 public void tearDown() throws Exception { 69 super.tearDown(); 70 mTestController.cleanupForTest(); 71 } 72 73 /** 74 * Lightweight subclass of the Controller class allows injection of mock context 75 */ 76 public static class TestController extends Controller { 77 78 protected TestController(Context providerContext, Context systemContext) { 79 super(systemContext); 80 setProviderContext(providerContext); 81 } 82 } 83 84 /** 85 * These are strings that should not change per locale. 86 */ 87 public void testGetMailboxServerName() { 88 assertEquals("", Controller.getMailboxServerName(mContext, -1)); 89 90 assertEquals("Inbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_INBOX)); 91 assertEquals("Outbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_OUTBOX)); 92 assertEquals("Trash", Controller.getMailboxServerName(mContext, Mailbox.TYPE_TRASH)); 93 assertEquals("Sent", Controller.getMailboxServerName(mContext, Mailbox.TYPE_SENT)); 94 assertEquals("Junk", Controller.getMailboxServerName(mContext, Mailbox.TYPE_JUNK)); 95 96 // Now try again with translation 97 Locale savedLocale = Locale.getDefault(); 98 Locale.setDefault(Locale.FRANCE); 99 assertEquals("Inbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_INBOX)); 100 assertEquals("Outbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_OUTBOX)); 101 assertEquals("Trash", Controller.getMailboxServerName(mContext, Mailbox.TYPE_TRASH)); 102 assertEquals("Sent", Controller.getMailboxServerName(mContext, Mailbox.TYPE_SENT)); 103 assertEquals("Junk", Controller.getMailboxServerName(mContext, Mailbox.TYPE_JUNK)); 104 Locale.setDefault(savedLocale); 105 } 106 107 /** 108 * Test of Controller.createMailbox(). 109 * Sunny day test only - creates a mailbox that does not exist. 110 * Does not test duplication, bad accountID, or any other bad input. 111 */ 112 public void testCreateMailbox() { 113 // safety check that system mailboxes don't exist ... 114 assertEquals(Mailbox.NO_MAILBOX, 115 Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_DRAFTS)); 116 assertEquals(Mailbox.NO_MAILBOX, 117 Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_SENT)); 118 119 long testMailboxId; 120 Mailbox testMailbox; 121 122 // Test creating "drafts" mailbox 123 mTestController.createMailbox(1L, Mailbox.TYPE_DRAFTS); 124 testMailboxId = Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_DRAFTS); 125 assertTrue(testMailboxId != Mailbox.NO_MAILBOX); 126 testMailbox = Mailbox.restoreMailboxWithId(mProviderContext, testMailboxId); 127 assertNotNull(testMailbox); 128 assertEquals(8, testMailbox.mFlags); // Flags should be "holds mail" 129 assertEquals(-1L, testMailbox.mParentKey); // Parent is off the top-level 130 131 // Test creating "sent" mailbox; same as drafts 132 mTestController.createMailbox(1L, Mailbox.TYPE_SENT); 133 testMailboxId = Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_SENT); 134 assertTrue(testMailboxId != Mailbox.NO_MAILBOX); 135 testMailbox = Mailbox.restoreMailboxWithId(mProviderContext, testMailboxId); 136 assertNotNull(testMailbox); 137 assertEquals(8, testMailbox.mFlags); // Flags should be "holds mail" 138 assertEquals(-1L, testMailbox.mParentKey); // Parent is off the top-level 139 } 140 141 /** 142 * Test of Controller.findOrCreateMailboxOfType(). 143 * Checks: 144 * - finds correctly the ID of existing mailbox 145 * - creates non-existing mailbox 146 * - creates only once a new mailbox 147 * - when accountId or mailboxType are -1, returns NO_MAILBOX 148 */ 149 public void testFindOrCreateMailboxOfType() { 150 Account account = ProviderTestUtils.setupAccount("mailboxid", true, mProviderContext); 151 long accountId = account.mId; 152 Mailbox box = ProviderTestUtils.setupMailbox("box", accountId, false, mProviderContext); 153 final int boxType = Mailbox.TYPE_TRASH; 154 box.mType = boxType; 155 box.save(mProviderContext); 156 long boxId = box.mId; 157 158 long testBoxId = mTestController.findOrCreateMailboxOfType(accountId, boxType); 159 160 // check it found the right mailbox id 161 assertEquals(boxId, testBoxId); 162 163 long boxId2 = mTestController.findOrCreateMailboxOfType(accountId, Mailbox.TYPE_DRAFTS); 164 assertTrue("mailbox created", boxId2 != Mailbox.NO_MAILBOX); 165 assertTrue("with different id", testBoxId != boxId2); 166 167 // check it doesn't create twice when existing 168 long boxId3 = mTestController.findOrCreateMailboxOfType(accountId, Mailbox.TYPE_DRAFTS); 169 assertEquals("don't create if exists", boxId3, boxId2); 170 171 // check invalid aruments 172 assertEquals(Mailbox.NO_MAILBOX, 173 mTestController.findOrCreateMailboxOfType(-1, Mailbox.TYPE_DRAFTS)); 174 assertEquals(Mailbox.NO_MAILBOX, mTestController.findOrCreateMailboxOfType(accountId, -1)); 175 } 176 177 /** 178 * Test the "move message" function. 179 */ 180 public void testMoveMessage() throws InterruptedException, ExecutionException { 181 Account account1 = ProviderTestUtils.setupAccount("message-move", true, mProviderContext); 182 long account1Id = account1.mId; 183 Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext); 184 long box1Id = box1.mId; 185 Mailbox box2 = ProviderTestUtils.setupMailbox("box2", account1Id, true, mProviderContext); 186 long box2Id = box2.mId; 187 Mailbox boxDest = ProviderTestUtils.setupMailbox("d", account1Id, true, mProviderContext); 188 long boxDestId = boxDest.mId; 189 190 Message message1 = ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, 191 true, mProviderContext); 192 Message message2 = ProviderTestUtils.setupMessage("message2", account1Id, box2Id, false, 193 true, mProviderContext); 194 long message1Id = message1.mId; 195 long message2Id = message2.mId; 196 197 // Because moveMessage runs asynchronously, call get() to force it to complete 198 mTestController.moveMessages(new long[] { message1Id, message2Id }, boxDestId).get(); 199 200 // now read back a fresh copy and confirm it's in the trash 201 assertEquals(boxDestId, EmailContent.Message.restoreMessageWithId(mProviderContext, 202 message1Id).mMailboxKey); 203 assertEquals(boxDestId, EmailContent.Message.restoreMessageWithId(mProviderContext, 204 message2Id).mMailboxKey); 205 } 206 207 /** 208 * Test the "delete message" function. Sunny day: 209 * - message/mailbox/account all exist 210 * - trash mailbox exists 211 */ 212 public void testDeleteMessage() { 213 Account account1 = ProviderTestUtils.setupAccount("message-delete", true, mProviderContext); 214 long account1Id = account1.mId; 215 Mailbox box = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext); 216 long boxId = box.mId; 217 218 Mailbox trashBox = ProviderTestUtils.setupMailbox("box2", account1Id, false, 219 mProviderContext); 220 trashBox.mType = Mailbox.TYPE_TRASH; 221 trashBox.save(mProviderContext); 222 long trashBoxId = trashBox.mId; 223 224 Mailbox draftBox = ProviderTestUtils.setupMailbox("box3", account1Id, false, 225 mProviderContext); 226 draftBox.mType = Mailbox.TYPE_DRAFTS; 227 draftBox.save(mProviderContext); 228 long draftBoxId = draftBox.mId; 229 230 { 231 // Case 1: Message in a regular mailbox, account known. 232 Message message = ProviderTestUtils.setupMessage("message1", account1Id, boxId, false, 233 true, mProviderContext); 234 long messageId = message.mId; 235 236 mTestController.deleteMessageSync(messageId); 237 238 // now read back a fresh copy and confirm it's in the trash 239 Message restored = EmailContent.Message.restoreMessageWithId(mProviderContext, 240 messageId); 241 assertEquals(trashBoxId, restored.mMailboxKey); 242 } 243 244 { 245 // Case 2: Already in trash 246 Message message = ProviderTestUtils.setupMessage("message3", account1Id, trashBoxId, 247 false, true, mProviderContext); 248 long messageId = message.mId; 249 250 mTestController.deleteMessageSync(messageId); 251 252 // Message should be deleted. 253 assertNull(EmailContent.Message.restoreMessageWithId(mProviderContext, messageId)); 254 } 255 256 { 257 // Case 3: Draft 258 Message message = ProviderTestUtils.setupMessage("message3", account1Id, draftBoxId, 259 false, true, mProviderContext); 260 long messageId = message.mId; 261 262 mTestController.deleteMessageSync(messageId); 263 264 // Message should be deleted. 265 assertNull(EmailContent.Message.restoreMessageWithId(mProviderContext, messageId)); 266 } 267 } 268 269 /** 270 * Test deleting message when there is no trash mailbox 271 */ 272 public void testDeleteMessageNoTrash() { 273 Account account1 = 274 ProviderTestUtils.setupAccount("message-delete-notrash", true, mProviderContext); 275 long account1Id = account1.mId; 276 Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext); 277 long box1Id = box1.mId; 278 279 Message message1 = 280 ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true, 281 mProviderContext); 282 long message1Id = message1.mId; 283 284 mTestController.deleteMessageSync(message1Id); 285 286 // now read back a fresh copy and confirm it's in the trash 287 Message message1get = 288 EmailContent.Message.restoreMessageWithId(mProviderContext, message1Id); 289 290 // check the new mailbox and see if it looks right 291 assertFalse(-1 == message1get.mMailboxKey); 292 assertFalse(box1Id == message1get.mMailboxKey); 293 Mailbox mailbox2get = Mailbox.restoreMailboxWithId(mProviderContext, 294 message1get.mMailboxKey); 295 assertEquals(Mailbox.TYPE_TRASH, mailbox2get.mType); 296 } 297 298 /** 299 * Test read/unread flag 300 */ 301 public void testReadUnread() throws InterruptedException, ExecutionException { 302 Account account1 = ProviderTestUtils.setupAccount("read-unread", false, mProviderContext); 303 account1.mHostAuthRecv 304 = ProviderTestUtils.setupHostAuth("read-unread", 0, false, mProviderContext); 305 account1.save(mProviderContext); 306 long account1Id = account1.mId; 307 long box1Id = 2; 308 309 Message message1 = 310 ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true, 311 mProviderContext); 312 long message1Id = message1.mId; 313 314 // test setting to "read" 315 mTestController.setMessageRead(message1Id, true).get(); 316 Message message1get = Message.restoreMessageWithId(mProviderContext, message1Id); 317 assertTrue(message1get.mFlagRead); 318 319 // test setting to "unread" 320 mTestController.setMessageRead(message1Id, false).get(); 321 message1get = Message.restoreMessageWithId(mProviderContext, message1Id); 322 assertFalse(message1get.mFlagRead); 323 324 // test setting to "read" 325 mTestController.setMessageRead(message1Id, true).get(); 326 message1get = Message.restoreMessageWithId(mProviderContext, message1Id); 327 assertTrue(message1get.mFlagRead); 328 } 329 330 /** 331 * Test favorites flag 332 */ 333 public void testFavorites() throws InterruptedException, ExecutionException { 334 Account account1 = ProviderTestUtils.setupAccount("favorites", false, mProviderContext); 335 account1.mHostAuthRecv 336 = ProviderTestUtils.setupHostAuth("favorites", 0, false, mProviderContext); 337 account1.save(mProviderContext); 338 long account1Id = account1.mId; 339 long box1Id = 2; 340 341 Message message1 = 342 ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true, 343 mProviderContext); 344 long message1Id = message1.mId; 345 346 // test setting to "favorite" 347 mTestController.setMessageFavorite(message1Id, true).get(); 348 Message message1get = Message.restoreMessageWithId(mProviderContext, message1Id); 349 assertTrue(message1get.mFlagFavorite); 350 351 // test setting to "not favorite" 352 mTestController.setMessageFavorite(message1Id, false).get(); 353 message1get = Message.restoreMessageWithId(mProviderContext, message1Id); 354 assertFalse(message1get.mFlagFavorite); 355 356 // test setting to "favorite" 357 mTestController.setMessageFavorite(message1Id, true).get(); 358 message1get = Message.restoreMessageWithId(mProviderContext, message1Id); 359 assertTrue(message1get.mFlagFavorite); 360 } 361 362 public void testGetAndDeleteAttachmentMailbox() { 363 Mailbox box = mTestController.getAttachmentMailbox(); 364 assertNotNull(box); 365 Mailbox anotherBox = mTestController.getAttachmentMailbox(); 366 assertNotNull(anotherBox); 367 // We should always get back the same Mailbox row 368 assertEquals(box.mId, anotherBox.mId); 369 // Add two messages to this mailbox 370 ProviderTestUtils.setupMessage("message1", 0, box.mId, false, true, 371 mProviderContext); 372 ProviderTestUtils.setupMessage("message2", 0, box.mId, false, true, 373 mProviderContext); 374 // Make sure we can find them where they are expected 375 assertEquals(2, EmailContent.count(mProviderContext, Message.CONTENT_URI, 376 Message.MAILBOX_KEY + "=?", new String[] {Long.toString(box.mId)})); 377 // Delete them 378 mTestController.deleteAttachmentMessages(); 379 // Make sure they're gone 380 assertEquals(0, EmailContent.count(mProviderContext, Message.CONTENT_URI, 381 Message.MAILBOX_KEY + "=?", new String[] {Long.toString(box.mId)})); 382 } 383 384 /** 385 * Test wiping an account's synced data. Everything should go, but account & empty inbox. 386 * Also ensures that the remaining account and the remaining inbox have cleared their 387 * server sync keys, to force refresh eventually. 388 */ 389 public void testWipeSyncedData() { 390 Account account1 = ProviderTestUtils.setupAccount("wipe-synced-1", false, mProviderContext); 391 account1.mSyncKey = "account-1-sync-key"; 392 account1.save(mProviderContext); 393 long account1Id = account1.mId; 394 Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, false, mProviderContext); 395 box1.mType = Mailbox.TYPE_INBOX; 396 box1.mSyncKey = "box-1-sync-key"; 397 box1.save(mProviderContext); 398 long box1Id = box1.mId; 399 Mailbox box2 = ProviderTestUtils.setupMailbox("box2", account1Id, true, mProviderContext); 400 long box2Id = box2.mId; 401 402 Account account2 = ProviderTestUtils.setupAccount("wipe-synced-2", false, mProviderContext); 403 account2.mSyncKey = "account-2-sync-key"; 404 account2.save(mProviderContext); 405 long account2Id = account2.mId; 406 Mailbox box3 = ProviderTestUtils.setupMailbox("box3", account2Id, false, mProviderContext); 407 box3.mSyncKey = "box-3-sync-key"; 408 box3.mType = Mailbox.TYPE_INBOX; 409 box3.save(mProviderContext); 410 long box3Id = box3.mId; 411 Mailbox box4 = ProviderTestUtils.setupMailbox("box4", account2Id, true, mProviderContext); 412 long box4Id = box4.mId; 413 414 // Now populate the 4 non-account boxes with messages 415 Message message = ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, 416 true, mProviderContext); 417 long message1Id = message.mId; 418 message = ProviderTestUtils.setupMessage("message2", account1Id, box2Id, false, 419 true, mProviderContext); 420 long message2Id = message.mId; 421 message = ProviderTestUtils.setupMessage("message3", account2Id, box3Id, false, 422 true, mProviderContext); 423 long message3Id = message.mId; 424 message = ProviderTestUtils.setupMessage("message4", account2Id, box4Id, false, 425 true, mProviderContext); 426 long message4Id = message.mId; 427 428 // Now wipe account 1's data 429 mTestController.deleteSyncedDataSync(account1Id); 430 431 // Confirm: Mailboxes gone (except account box), all messages gone, account survives 432 assertNull(Mailbox.restoreMailboxWithId(mProviderContext, box1Id)); 433 assertNull(Mailbox.restoreMailboxWithId(mProviderContext, box2Id)); 434 assertNull(Message.restoreMessageWithId(mProviderContext, message1Id)); 435 assertNull(Message.restoreMessageWithId(mProviderContext, message2Id)); 436 account1 = Account.restoreAccountWithId(mProviderContext, account1Id); 437 assertNotNull(account1); 438 assertNull(account1.mSyncKey); 439 440 // Confirm: Other account survived 441 assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, box3Id)); 442 assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, box4Id)); 443 assertNotNull(Message.restoreMessageWithId(mProviderContext, message3Id)); 444 assertNotNull(Message.restoreMessageWithId(mProviderContext, message4Id)); 445 assertNotNull(Account.restoreAccountWithId(mProviderContext, account2Id)); 446 } 447 448 public void testLoadMessageFromUri() throws Exception { 449 // Create a simple message 450 Message msg = new Message(); 451 String text = "This is some text"; 452 msg.mText = text; 453 String sender = "sender@host.com"; 454 msg.mFrom = sender; 455 // Save this away 456 msg.save(mProviderContext); 457 458 Uri fileUri = ProviderTestUtils.createTempEmlFile(mProviderContext, msg, 459 mContext.getFilesDir()); 460 461 // Load the message via Controller and a Uri 462 Message loadedMsg = mTestController.loadMessageFromUri(fileUri); 463 464 // Check server id, mailbox key, account key, and from 465 assertNotNull(loadedMsg); 466 assertTrue(loadedMsg.mServerId.startsWith(Controller.ATTACHMENT_MESSAGE_UID_PREFIX)); 467 Mailbox box = mTestController.getAttachmentMailbox(); 468 assertNotNull(box); 469 assertEquals(box.mId, loadedMsg.mMailboxKey); 470 assertEquals(0, loadedMsg.mAccountKey); 471 assertEquals(loadedMsg.mFrom, sender); 472 // Check body text 473 String loadedMsgText = Body.restoreBodyTextWithMessageId(mProviderContext, loadedMsg.mId); 474 assertEquals(text, loadedMsgText); 475 } 476 477 /** 478 * Create a simple HostAuth with protocol 479 */ 480 private HostAuth setupSimpleHostAuth(String protocol) { 481 HostAuth hostAuth = new HostAuth(); 482 hostAuth.mProtocol = protocol; 483 return hostAuth; 484 } 485 486 public void testIsMessagingController() { 487 Account account1 = ProviderTestUtils.setupAccount("account1", false, 488 mProviderContext); 489 account1.mHostAuthRecv = setupSimpleHostAuth("eas"); 490 account1.save(mProviderContext); 491 assertFalse(mTestController.isMessagingController(account1)); 492 Account account2 = ProviderTestUtils.setupAccount("account2", false, 493 mProviderContext); 494 account2.mHostAuthRecv = setupSimpleHostAuth("imap"); 495 account2.save(mProviderContext); 496 assertTrue(mTestController.isMessagingController(account2)); 497 Account account3 = ProviderTestUtils.setupAccount("account3", false, 498 mProviderContext); 499 account3.mHostAuthRecv = setupSimpleHostAuth("pop3"); 500 account3.save(mProviderContext); 501 assertTrue(mTestController.isMessagingController(account3)); 502 Account account4 = ProviderTestUtils.setupAccount("account4", false, 503 mProviderContext); 504 account4.mHostAuthRecv = setupSimpleHostAuth("smtp"); 505 account4.save(mProviderContext); 506 assertFalse(mTestController.isMessagingController(account4)); 507 // There should be values for all of these accounts in the legacy map 508 assertNotNull(mTestController.mLegacyControllerMap.get(account1.mId)); 509 assertNotNull(mTestController.mLegacyControllerMap.get(account2.mId)); 510 assertNotNull(mTestController.mLegacyControllerMap.get(account3.mId)); 511 assertNotNull(mTestController.mLegacyControllerMap.get(account4.mId)); 512 // The map should have the expected values 513 assertFalse(mTestController.mLegacyControllerMap.get(account1.mId)); 514 assertTrue(mTestController.mLegacyControllerMap.get(account2.mId)); 515 assertTrue(mTestController.mLegacyControllerMap.get(account3.mId)); 516 assertFalse(mTestController.mLegacyControllerMap.get(account4.mId)); 517 // This second pass should pull values from the cache 518 assertFalse(mTestController.isMessagingController(account1)); 519 assertTrue(mTestController.isMessagingController(account2)); 520 assertTrue(mTestController.isMessagingController(account3)); 521 assertFalse(mTestController.isMessagingController(account4)); 522 } 523 524 /** 525 * TODO: releasing associated data (e.g. attachments, embedded images) 526 */ 527} 528