email/activity/MailboxFinderTest.java

/*
 * Copyright (C) 2010 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.activity;

import android.content.Context;
import android.test.InstrumentationTestCase;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.LargeTest;

import com.android.email.Controller;
import com.android.email.DBTestHelper;
import com.android.email.Email;
import com.android.email.TestUtils;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.mail.MessagingException;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.Mailbox;

/**
 * Test case for {@link MailboxFinder}.
 *
 * We need to use {@link InstrumentationTestCase} so that we can create AsyncTasks on the UI thread
 * using {@link InstrumentationTestCase#runTestOnUiThread}.  This class also needs an isolated
 * context, which is provided by {@link ProviderTestCase2}.  We can't derive from two classes,
 * so we just copy the code for an isolate context to here.
 */
@LargeTest
public class MailboxFinderTest extends InstrumentationTestCase {
    private static final int TIMEOUT = 10; // in seconds

    // Test target
    private MailboxFinder mMailboxFinder;

    // Isolted Context for providers.
    private Context mProviderContext;

    // Mock to track callback invocations.
    private MockController mMockController;
    private MockCallback mCallback;

    private Context getContext() {
        return getInstrumentation().getTargetContext();
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
                getInstrumentation().getTargetContext());
        mCallback = new MockCallback();
        mMockController = new MockController(getContext());
        Controller.injectMockControllerForTest(mMockController);
        assertEquals(0, mMockController.getResultCallbacksForTest().size());
    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        if (mMailboxFinder != null) {
            mMailboxFinder.cancel();

            // MailboxFinder should unregister its listener when closed.
            checkControllerResultRemoved(mMockController);
        }
        mMockController.cleanupForTest();
        Controller.injectMockControllerForTest(null);
    }

    /**
     * Make sure no {@link MailboxFinder.Callback} is left registered to the controller.
     */
    private static void checkControllerResultRemoved(Controller controller) {
        for (Controller.Result callback : controller.getResultCallbacksForTest()) {
            assertFalse(callback instanceof MailboxFinder.Callback);
        }
    }

    /**
     * Create an account and returns the ID.
     */
    private long createAccount(boolean securityHold) {
        Account acct = ProviderTestUtils.setupAccount("acct1", false, mProviderContext);
        if (securityHold) {
            acct.mFlags |= Account.FLAGS_SECURITY_HOLD;
        }
        acct.save(mProviderContext);
        return acct.mId;
    }

    /**
     * Create a mailbox and return the ID.
     */
    private long createMailbox(long accountId, int mailboxType) {
        Mailbox box = new Mailbox();
        box.mServerId = box.mDisplayName = "mailbox";
        box.mAccountKey = accountId;
        box.mType = mailboxType;
        box.mFlagVisible = true;
        box.mVisibleLimit = Email.VISIBLE_LIMIT_DEFAULT;
        box.save(mProviderContext);
        return box.mId;
    }

    /**
     * Create a {@link MailboxFinder} and kick it.
     */
    private void createAndStartFinder(final long accountId, final int mailboxType)
            throws Throwable {
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                mMailboxFinder = new MailboxFinder(mProviderContext, accountId, mailboxType,
                        mCallback);
                mMailboxFinder.startLookup();
                assertTrue(mMailboxFinder.isStartedForTest());
            }
        });
    }

    /**
     * Wait until any of the {@link MailboxFinder.Callback} method or
     * {@link Controller#updateMailboxList} is called.
     */
    private void waitUntilCallbackCalled() {
        TestUtils.waitUntil("", new TestUtils.Condition() {
            @Override
            public boolean isMet() {
                return mCallback.isAnyMethodCalled() || mMockController.mCalledUpdateMailboxList;
            }
        }, TIMEOUT);
    }

    /**
     * Test: Account is on security hold.
     */
    public void testSecurityHold() throws Throwable {
        final long accountId = createAccount(true);

        createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
        waitUntilCallbackCalled();

        assertFalse(mCallback.mCalledAccountNotFound);
        assertTrue(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * Test: Account does not exist.
     */
    public void testAccountNotFound() throws Throwable {
        createAndStartFinder(123456, Mailbox.TYPE_INBOX); // No such account.
        waitUntilCallbackCalled();

        assertTrue(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * Test: Mailbox found
     */
    public void testMailboxFound() throws Throwable {
        final long accountId = createAccount(false);
        final long mailboxId = createMailbox(accountId, Mailbox.TYPE_INBOX);

        createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
        waitUntilCallbackCalled();

        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertTrue(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertEquals(accountId, mCallback.mAccountId);
        assertEquals(mailboxId, mCallback.mMailboxId);

        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * Common initialization for tests that involves network-lookup.
     */
    private void prepareForNetworkLookupTest(final long accountId) throws Throwable {
        // Look for non-existing mailbox.
        createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
        waitUntilCallbackCalled();

        // Mailbox not found, so the finder should try network-looking up.
        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);

        // Controller.updateMailboxList() should have been called, with the account id.
        assertTrue(mMockController.mCalledUpdateMailboxList);
        assertEquals(accountId, mMockController.mPassedAccountId);

        mMockController.reset();

        assertFalse(mMailboxFinder.isReallyClosedForTest()); // Not closed yet
    }

    /**
     * Test: Account exists, but mailbox doesn't -> Get {@link Controller} to update the mailbox
     * list -> mailbox still doesn't exist.
     */
    public void testMailboxNotFound() throws Throwable {
        final long accountId = createAccount(false);

        prepareForNetworkLookupTest(accountId);

        // Imitate the mCallback...
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
                        null, accountId, 100);
            }
        });

        // Task should have started, so wait for the response...
        waitUntilCallbackCalled();

        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertTrue(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * Test: Account exists, but mailbox doesn't -> Get {@link Controller} to update the mailbox
     * list -> found mailbox this time.
     */
    public void testMailboxFoundOnNetwork() throws Throwable {
        final long accountId = createAccount(false);

        prepareForNetworkLookupTest(accountId);

        // Create mailbox at this point.
        final long mailboxId = createMailbox(accountId, Mailbox.TYPE_INBOX);

        // Imitate the mCallback...
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
                        null, accountId, 100);
            }
        });

        // Task should have started, so wait for the response...
        waitUntilCallbackCalled();

        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertTrue(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertEquals(accountId, mCallback.mAccountId);
        assertEquals(mailboxId, mCallback.mMailboxId);

        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * Test: Account exists, but mailbox doesn't -> Get {@link Controller} to update the mailbox
     * list -> network error.
     */
    public void testMailboxNotFoundNetworkError() throws Throwable {
        final long accountId = createAccount(false);

        prepareForNetworkLookupTest(accountId);

        // Imitate the mCallback...
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                // network error.
                mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
                        new MessagingException("Network error"), accountId, 0);
            }
        });

        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertTrue(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * Test: updateMailboxListCallback won't respond to update of a non-target account.
     */
    public void testUpdateMailboxListCallbackNonTarget() throws Throwable {
        final long accountId = createAccount(false);

        prepareForNetworkLookupTest(accountId);

        // Callback from Controller, but for a different account.
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                long nonTargetAccountId = accountId + 1;
                mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
                        new MessagingException("Network error"), nonTargetAccountId, 0);
            }
        });

        // Nothing happened.
        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);
        assertFalse(mMockController.mCalledUpdateMailboxList);

        assertFalse(mMailboxFinder.isReallyClosedForTest()); // Not closed yet
    }

    /**
     * Test: Mailbox not found (mailbox of different type exists)
     */
    public void testMailboxNotFound2() throws Throwable {
        final long accountId = createAccount(false);
        final long mailboxId = createMailbox(accountId, Mailbox.TYPE_DRAFTS);

        createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
        waitUntilCallbackCalled();

        assertFalse(mCallback.mCalledAccountNotFound);
        assertFalse(mCallback.mCalledAccountSecurityHold);
        assertFalse(mCallback.mCalledMailboxFound);
        assertFalse(mCallback.mCalledMailboxNotFound);
        assertTrue(mMockController.mCalledUpdateMailboxList);

        assertFalse(mMailboxFinder.isReallyClosedForTest()); // Not closed yet -- network lookup.
    }

    /**
     * Test: Call {@link MailboxFinder#startLookup()} twice, which should throw an ISE.
     */
    public void testRunTwice() throws Throwable {
        final long accountId = createAccount(true);

        createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
        try {
            mMailboxFinder.startLookup();
            fail("Expected exception not thrown");
        } catch (IllegalStateException ok) {
        }
    }

    public void testCancel() throws Throwable {
        final long accountId = createAccount(true);

        createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
        mMailboxFinder.cancel();
        assertTrue(mMailboxFinder.isReallyClosedForTest());
    }

    /**
     * A {@link Controller} that remembers if updateMailboxList has been called.
     */
    private static class MockController extends Controller {
        public volatile long mPassedAccountId;
        public volatile boolean mCalledUpdateMailboxList;

        public void reset() {
            mPassedAccountId = -1;
            mCalledUpdateMailboxList = false;
        }

        protected MockController(Context context) {
            super(context);
        }

        @Override
        public void updateMailboxList(long accountId) {
            mCalledUpdateMailboxList = true;
            mPassedAccountId = accountId;
        }
    }

    /**
     * Callback that logs what method is called with what arguments.
     */
    private static class MockCallback implements MailboxFinder.Callback {
        public volatile boolean mCalledAccountNotFound;
        public volatile boolean mCalledAccountSecurityHold;
        public volatile boolean mCalledMailboxFound;
        public volatile boolean mCalledMailboxNotFound;

        public volatile long mAccountId = -1;
        public volatile long mMailboxId = -1;

        public boolean isAnyMethodCalled() {
            return mCalledAccountNotFound || mCalledAccountSecurityHold || mCalledMailboxFound
                    || mCalledMailboxNotFound;
        }

        @Override
        public void onAccountNotFound() {
            mCalledAccountNotFound = true;
        }

        @Override
        public void onAccountSecurityHold(long accountId) {
            mCalledAccountSecurityHold = true;
            mAccountId = accountId;
        }

        @Override
        public void onMailboxFound(long accountId, long mailboxId) {
            mCalledMailboxFound = true;
            mAccountId = accountId;
            mMailboxId = mailboxId;
        }

        @Override
        public void onMailboxNotFound(long accountId) {
            mCalledMailboxNotFound = true;
            mAccountId = accountId;
        }
    }
}