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