/*
* Copyright (C) 2009 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.email;
import android.content.Context;
import android.net.Uri;
import android.test.ProviderTestCase2;
import com.android.email.provider.ContentCache;
import com.android.email.provider.EmailProvider;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Body;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.HostAuth;
import com.android.emailcommon.provider.Mailbox;
import java.util.Locale;
import java.util.concurrent.ExecutionException;
/**
* Tests of the Controller class that depend on the underlying provider.
*
* NOTE: It would probably make sense to rewrite this using a MockProvider, instead of the
* ProviderTestCase (which is a real provider running on a temp database). This would be more of
* a true "unit test".
*
* You can run this entire test case with:
* runtest -c com.android.email.ControllerProviderOpsTests email
*/
public class ControllerProviderOpsTests extends ProviderTestCase2<EmailProvider> {
private Context mProviderContext;
private Context mContext;
private TestController mTestController;
public ControllerProviderOpsTests() {
super(EmailProvider.class, EmailContent.AUTHORITY);
}
@Override
public void setUp() throws Exception {
super.setUp();
mProviderContext = getMockContext();
mContext = getContext();
mTestController = new TestController(mProviderContext, mContext);
// Invalidate all caches, since we reset the database for each test
ContentCache.invalidateAllCaches();
}
@Override
public void tearDown() throws Exception {
super.tearDown();
mTestController.cleanupForTest();
}
/**
* Lightweight subclass of the Controller class allows injection of mock context
*/
public static class TestController extends Controller {
protected TestController(Context providerContext, Context systemContext) {
super(systemContext);
setProviderContext(providerContext);
}
}
/**
* These are strings that should not change per locale.
*/
public void testGetMailboxServerName() {
assertEquals("", Controller.getMailboxServerName(mContext, -1));
assertEquals("Inbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_INBOX));
assertEquals("Outbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_OUTBOX));
assertEquals("Trash", Controller.getMailboxServerName(mContext, Mailbox.TYPE_TRASH));
assertEquals("Sent", Controller.getMailboxServerName(mContext, Mailbox.TYPE_SENT));
assertEquals("Junk", Controller.getMailboxServerName(mContext, Mailbox.TYPE_JUNK));
// Now try again with translation
Locale savedLocale = Locale.getDefault();
Locale.setDefault(Locale.FRANCE);
assertEquals("Inbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_INBOX));
assertEquals("Outbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_OUTBOX));
assertEquals("Trash", Controller.getMailboxServerName(mContext, Mailbox.TYPE_TRASH));
assertEquals("Sent", Controller.getMailboxServerName(mContext, Mailbox.TYPE_SENT));
assertEquals("Junk", Controller.getMailboxServerName(mContext, Mailbox.TYPE_JUNK));
Locale.setDefault(savedLocale);
}
/**
* Test of Controller.createMailbox().
* Sunny day test only - creates a mailbox that does not exist.
* Does not test duplication, bad accountID, or any other bad input.
*/
public void testCreateMailbox() {
// safety check that system mailboxes don't exist ...
assertEquals(Mailbox.NO_MAILBOX,
Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_DRAFTS));
assertEquals(Mailbox.NO_MAILBOX,
Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_SENT));
long testMailboxId;
Mailbox testMailbox;
// Test creating "drafts" mailbox
mTestController.createMailbox(1L, Mailbox.TYPE_DRAFTS);
testMailboxId = Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_DRAFTS);
assertTrue(testMailboxId != Mailbox.NO_MAILBOX);
testMailbox = Mailbox.restoreMailboxWithId(mProviderContext, testMailboxId);
assertNotNull(testMailbox);
assertEquals(8, testMailbox.mFlags); // Flags should be "holds mail"
assertEquals(-1L, testMailbox.mParentKey); // Parent is off the top-level
// Test creating "sent" mailbox; same as drafts
mTestController.createMailbox(1L, Mailbox.TYPE_SENT);
testMailboxId = Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_SENT);
assertTrue(testMailboxId != Mailbox.NO_MAILBOX);
testMailbox = Mailbox.restoreMailboxWithId(mProviderContext, testMailboxId);
assertNotNull(testMailbox);
assertEquals(8, testMailbox.mFlags); // Flags should be "holds mail"
assertEquals(-1L, testMailbox.mParentKey); // Parent is off the top-level
}
/**
* Test of Controller.findOrCreateMailboxOfType().
* Checks:
* - finds correctly the ID of existing mailbox
* - creates non-existing mailbox
* - creates only once a new mailbox
* - when accountId or mailboxType are -1, returns NO_MAILBOX
*/
public void testFindOrCreateMailboxOfType() {
Account account = ProviderTestUtils.setupAccount("mailboxid", true, mProviderContext);
long accountId = account.mId;
Mailbox box = ProviderTestUtils.setupMailbox("box", accountId, false, mProviderContext);
final int boxType = Mailbox.TYPE_TRASH;
box.mType = boxType;
box.save(mProviderContext);
long boxId = box.mId;
long testBoxId = mTestController.findOrCreateMailboxOfType(accountId, boxType);
// check it found the right mailbox id
assertEquals(boxId, testBoxId);
long boxId2 = mTestController.findOrCreateMailboxOfType(accountId, Mailbox.TYPE_DRAFTS);
assertTrue("mailbox created", boxId2 != Mailbox.NO_MAILBOX);
assertTrue("with different id", testBoxId != boxId2);
// check it doesn't create twice when existing
long boxId3 = mTestController.findOrCreateMailboxOfType(accountId, Mailbox.TYPE_DRAFTS);
assertEquals("don't create if exists", boxId3, boxId2);
// check invalid aruments
assertEquals(Mailbox.NO_MAILBOX,
mTestController.findOrCreateMailboxOfType(-1, Mailbox.TYPE_DRAFTS));
assertEquals(Mailbox.NO_MAILBOX, mTestController.findOrCreateMailboxOfType(accountId, -1));
}
/**
* Test the "move message" function.
*/
public void testMoveMessage() throws InterruptedException, ExecutionException {
Account account1 = ProviderTestUtils.setupAccount("message-move", true, mProviderContext);
long account1Id = account1.mId;
Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext);
long box1Id = box1.mId;
Mailbox box2 = ProviderTestUtils.setupMailbox("box2", account1Id, true, mProviderContext);
long box2Id = box2.mId;
Mailbox boxDest = ProviderTestUtils.setupMailbox("d", account1Id, true, mProviderContext);
long boxDestId = boxDest.mId;
Message message1 = ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false,
true, mProviderContext);
Message message2 = ProviderTestUtils.setupMessage("message2", account1Id, box2Id, false,
true, mProviderContext);
long message1Id = message1.mId;
long message2Id = message2.mId;
// Because moveMessage runs asynchronously, call get() to force it to complete
mTestController.moveMessages(new long[] { message1Id, message2Id }, boxDestId).get();
// now read back a fresh copy and confirm it's in the trash
assertEquals(boxDestId, EmailContent.Message.restoreMessageWithId(mProviderContext,
message1Id).mMailboxKey);
assertEquals(boxDestId, EmailContent.Message.restoreMessageWithId(mProviderContext,
message2Id).mMailboxKey);
}
/**
* Test the "delete message" function. Sunny day:
* - message/mailbox/account all exist
* - trash mailbox exists
*/
public void testDeleteMessage() {
Account account1 = ProviderTestUtils.setupAccount("message-delete", true, mProviderContext);
long account1Id = account1.mId;
Mailbox box = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext);
long boxId = box.mId;
Mailbox trashBox = ProviderTestUtils.setupMailbox("box2", account1Id, false,
mProviderContext);
trashBox.mType = Mailbox.TYPE_TRASH;
trashBox.save(mProviderContext);
long trashBoxId = trashBox.mId;
Mailbox draftBox = ProviderTestUtils.setupMailbox("box3", account1Id, false,
mProviderContext);
draftBox.mType = Mailbox.TYPE_DRAFTS;
draftBox.save(mProviderContext);
long draftBoxId = draftBox.mId;
{
// Case 1: Message in a regular mailbox, account known.
Message message = ProviderTestUtils.setupMessage("message1", account1Id, boxId, false,
true, mProviderContext);
long messageId = message.mId;
mTestController.deleteMessageSync(messageId);
// now read back a fresh copy and confirm it's in the trash
Message restored = EmailContent.Message.restoreMessageWithId(mProviderContext,
messageId);
assertEquals(trashBoxId, restored.mMailboxKey);
}
{
// Case 2: Already in trash
Message message = ProviderTestUtils.setupMessage("message3", account1Id, trashBoxId,
false, true, mProviderContext);
long messageId = message.mId;
mTestController.deleteMessageSync(messageId);
// Message should be deleted.
assertNull(EmailContent.Message.restoreMessageWithId(mProviderContext, messageId));
}
{
// Case 3: Draft
Message message = ProviderTestUtils.setupMessage("message3", account1Id, draftBoxId,
false, true, mProviderContext);
long messageId = message.mId;
mTestController.deleteMessageSync(messageId);
// Message should be deleted.
assertNull(EmailContent.Message.restoreMessageWithId(mProviderContext, messageId));
}
}
/**
* Test deleting message when there is no trash mailbox
*/
public void testDeleteMessageNoTrash() {
Account account1 =
ProviderTestUtils.setupAccount("message-delete-notrash", true, mProviderContext);
long account1Id = account1.mId;
Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext);
long box1Id = box1.mId;
Message message1 =
ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true,
mProviderContext);
long message1Id = message1.mId;
mTestController.deleteMessageSync(message1Id);
// now read back a fresh copy and confirm it's in the trash
Message message1get =
EmailContent.Message.restoreMessageWithId(mProviderContext, message1Id);
// check the new mailbox and see if it looks right
assertFalse(-1 == message1get.mMailboxKey);
assertFalse(box1Id == message1get.mMailboxKey);
Mailbox mailbox2get = Mailbox.restoreMailboxWithId(mProviderContext,
message1get.mMailboxKey);
assertEquals(Mailbox.TYPE_TRASH, mailbox2get.mType);
}
/**
* Test read/unread flag
*/
public void testReadUnread() throws InterruptedException, ExecutionException {
Account account1 = ProviderTestUtils.setupAccount("read-unread", false, mProviderContext);
account1.mHostAuthRecv
= ProviderTestUtils.setupHostAuth("read-unread", 0, false, mProviderContext);
account1.save(mProviderContext);
long account1Id = account1.mId;
long box1Id = 2;
Message message1 =
ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true,
mProviderContext);
long message1Id = message1.mId;
// test setting to "read"
mTestController.setMessageRead(message1Id, true).get();
Message message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagRead);
// test setting to "unread"
mTestController.setMessageRead(message1Id, false).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertFalse(message1get.mFlagRead);
// test setting to "read"
mTestController.setMessageRead(message1Id, true).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagRead);
}
/**
* Test favorites flag
*/
public void testFavorites() throws InterruptedException, ExecutionException {
Account account1 = ProviderTestUtils.setupAccount("favorites", false, mProviderContext);
account1.mHostAuthRecv
= ProviderTestUtils.setupHostAuth("favorites", 0, false, mProviderContext);
account1.save(mProviderContext);
long account1Id = account1.mId;
long box1Id = 2;
Message message1 =
ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true,
mProviderContext);
long message1Id = message1.mId;
// test setting to "favorite"
mTestController.setMessageFavorite(message1Id, true).get();
Message message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagFavorite);
// test setting to "not favorite"
mTestController.setMessageFavorite(message1Id, false).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertFalse(message1get.mFlagFavorite);
// test setting to "favorite"
mTestController.setMessageFavorite(message1Id, true).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagFavorite);
}
public void testGetAndDeleteAttachmentMailbox() {
Mailbox box = mTestController.getAttachmentMailbox();
assertNotNull(box);
Mailbox anotherBox = mTestController.getAttachmentMailbox();
assertNotNull(anotherBox);
// We should always get back the same Mailbox row
assertEquals(box.mId, anotherBox.mId);
// Add two messages to this mailbox
ProviderTestUtils.setupMessage("message1", 0, box.mId, false, true,
mProviderContext);
ProviderTestUtils.setupMessage("message2", 0, box.mId, false, true,
mProviderContext);
// Make sure we can find them where they are expected
assertEquals(2, EmailContent.count(mProviderContext, Message.CONTENT_URI,
Message.MAILBOX_KEY + "=?", new String[] {Long.toString(box.mId)}));
// Delete them
mTestController.deleteAttachmentMessages();
// Make sure they're gone
assertEquals(0, EmailContent.count(mProviderContext, Message.CONTENT_URI,
Message.MAILBOX_KEY + "=?", new String[] {Long.toString(box.mId)}));
}
/**
* Test wiping an account's synced data. Everything should go, but account & empty inbox.
* Also ensures that the remaining account and the remaining inbox have cleared their
* server sync keys, to force refresh eventually.
*/
public void testWipeSyncedData() {
Account account1 = ProviderTestUtils.setupAccount("wipe-synced-1", false, mProviderContext);
account1.mSyncKey = "account-1-sync-key";
account1.save(mProviderContext);
long account1Id = account1.mId;
Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, false, mProviderContext);
box1.mType = Mailbox.TYPE_INBOX;
box1.mSyncKey = "box-1-sync-key";
box1.save(mProviderContext);
long box1Id = box1.mId;
Mailbox box2 = ProviderTestUtils.setupMailbox("box2", account1Id, true, mProviderContext);
long box2Id = box2.mId;
// An EAS account mailbox
Mailbox eas = ProviderTestUtils.setupMailbox("eas", account1Id, false, mProviderContext);
eas.mType = Mailbox.TYPE_EAS_ACCOUNT_MAILBOX;
eas.save(mProviderContext);
Account account2 = ProviderTestUtils.setupAccount("wipe-synced-2", false, mProviderContext);
account2.mSyncKey = "account-2-sync-key";
account2.save(mProviderContext);
long account2Id = account2.mId;
Mailbox box3 = ProviderTestUtils.setupMailbox("box3", account2Id, false, mProviderContext);
box3.mSyncKey = "box-3-sync-key";
box3.mType = Mailbox.TYPE_INBOX;
box3.save(mProviderContext);
long box3Id = box3.mId;
Mailbox box4 = ProviderTestUtils.setupMailbox("box4", account2Id, true, mProviderContext);
long box4Id = box4.mId;
// Now populate the 4 non-account boxes with messages
Message message = ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false,
true, mProviderContext);
long message1Id = message.mId;
message = ProviderTestUtils.setupMessage("message2", account1Id, box2Id, false,
true, mProviderContext);
long message2Id = message.mId;
message = ProviderTestUtils.setupMessage("message3", account2Id, box3Id, false,
true, mProviderContext);
long message3Id = message.mId;
message = ProviderTestUtils.setupMessage("message4", account2Id, box4Id, false,
true, mProviderContext);
long message4Id = message.mId;
// Now wipe account 1's data
mTestController.deleteSyncedDataSync(account1Id);
// Confirm: Mailboxes gone (except account box), all messages gone, account survives
assertNull(Mailbox.restoreMailboxWithId(mProviderContext, box1Id));
assertNull(Mailbox.restoreMailboxWithId(mProviderContext, box2Id));
assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, eas.mId));
assertNull(Message.restoreMessageWithId(mProviderContext, message1Id));
assertNull(Message.restoreMessageWithId(mProviderContext, message2Id));
account1 = Account.restoreAccountWithId(mProviderContext, account1Id);
assertNotNull(account1);
assertNull(account1.mSyncKey);
// Confirm: Other account survived
assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, box3Id));
assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, box4Id));
assertNotNull(Message.restoreMessageWithId(mProviderContext, message3Id));
assertNotNull(Message.restoreMessageWithId(mProviderContext, message4Id));
assertNotNull(Account.restoreAccountWithId(mProviderContext, account2Id));
}
public void testLoadMessageFromUri() throws Exception {
// Create a simple message
Message msg = new Message();
String text = "This is some text";
msg.mText = text;
String sender = "sender@host.com";
msg.mFrom = sender;
// Save this away
msg.save(mProviderContext);
Uri fileUri = ProviderTestUtils.createTempEmlFile(mProviderContext, msg,
mContext.getFilesDir());
// Load the message via Controller and a Uri
Message loadedMsg = mTestController.loadMessageFromUri(fileUri);
// Check server id, mailbox key, account key, and from
assertNotNull(loadedMsg);
assertTrue(loadedMsg.mServerId.startsWith(Controller.ATTACHMENT_MESSAGE_UID_PREFIX));
Mailbox box = mTestController.getAttachmentMailbox();
assertNotNull(box);
assertEquals(box.mId, loadedMsg.mMailboxKey);
assertEquals(0, loadedMsg.mAccountKey);
assertEquals(loadedMsg.mFrom, sender);
// Check body text
String loadedMsgText = Body.restoreBodyTextWithMessageId(mProviderContext, loadedMsg.mId);
assertEquals(text, loadedMsgText);
}
/**
* Create a simple HostAuth with protocol
*/
private HostAuth setupSimpleHostAuth(String protocol) {
HostAuth hostAuth = new HostAuth();
hostAuth.mProtocol = protocol;
return hostAuth;
}
public void testIsMessagingController() {
Account account1 = ProviderTestUtils.setupAccount("account1", false,
mProviderContext);
account1.mHostAuthRecv = setupSimpleHostAuth("eas");
account1.save(mProviderContext);
assertFalse(mTestController.isMessagingController(account1));
Account account2 = ProviderTestUtils.setupAccount("account2", false,
mProviderContext);
account2.mHostAuthRecv = setupSimpleHostAuth("imap");
account2.save(mProviderContext);
assertTrue(mTestController.isMessagingController(account2));
Account account3 = ProviderTestUtils.setupAccount("account3", false,
mProviderContext);
account3.mHostAuthRecv = setupSimpleHostAuth("pop3");
account3.save(mProviderContext);
assertTrue(mTestController.isMessagingController(account3));
Account account4 = ProviderTestUtils.setupAccount("account4", false,
mProviderContext);
account4.mHostAuthRecv = setupSimpleHostAuth("smtp");
account4.save(mProviderContext);
assertFalse(mTestController.isMessagingController(account4));
// There should be values for all of these accounts in the legacy map
assertNotNull(mTestController.mLegacyControllerMap.get(account1.mId));
assertNotNull(mTestController.mLegacyControllerMap.get(account2.mId));
assertNotNull(mTestController.mLegacyControllerMap.get(account3.mId));
assertNotNull(mTestController.mLegacyControllerMap.get(account4.mId));
// The map should have the expected values
assertFalse(mTestController.mLegacyControllerMap.get(account1.mId));
assertTrue(mTestController.mLegacyControllerMap.get(account2.mId));
assertTrue(mTestController.mLegacyControllerMap.get(account3.mId));
assertFalse(mTestController.mLegacyControllerMap.get(account4.mId));
// This second pass should pull values from the cache
assertFalse(mTestController.isMessagingController(account1));
assertTrue(mTestController.isMessagingController(account2));
assertTrue(mTestController.isMessagingController(account3));
assertFalse(mTestController.isMessagingController(account4));
}
/**
* TODO: releasing associated data (e.g. attachments, embedded images)
*/
}