managedprovisioning/task/StartManagedProfileTaskTest.java

/*
 * Copyright (C) 2016 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.managedprovisioning.task;

import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;

import android.app.IActivityManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.RemoteException;
import android.os.UserHandle;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;

import com.android.managedprovisioning.model.ProvisioningParams;

import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Unit tests for {@link StartManagedProfileTask}.
 */
public class StartManagedProfileTaskTest extends AndroidTestCase {
    private static final int TEST_USER_ID = 123;
    private static final String TEST_MDM_PACKAGE_NAME = "com.test.mdm";
    private static final ProvisioningParams TEST_PARAMS = new ProvisioningParams.Builder()
            .setDeviceAdminPackageName(TEST_MDM_PACKAGE_NAME)
            .setProvisioningAction(ACTION_PROVISION_MANAGED_PROFILE)
            .build();
    private static final Intent UNLOCK_INTENT = new Intent(Intent.ACTION_USER_UNLOCKED)
            .putExtra(Intent.EXTRA_USER_HANDLE, TEST_USER_ID);

    @Mock private IActivityManager mIActivityManager;
    @Mock private Context mContext;
    @Mock private AbstractProvisioningTask.Callback mCallback;
    private ArgumentCaptor<BroadcastReceiver> mReceiverCaptor =
            ArgumentCaptor.forClass(BroadcastReceiver.class);

    private StartManagedProfileTask mTask;
    private HandlerThread mHandlerThread;
    private final CountDownLatch mStartInBackgroundLatch = new CountDownLatch(1);
    private final CountDownLatch mSuccessLatch = new CountDownLatch(1);

    public void setUp() {
        // this is necessary for mockito to work
        System.setProperty("dexmaker.dexcache", getContext().getCacheDir().toString());
        MockitoAnnotations.initMocks(this);

        mHandlerThread = new HandlerThread("Test thread");
        mHandlerThread.start();

        mTask = new StartManagedProfileTask(mIActivityManager, mContext, TEST_PARAMS, mCallback);

        // register a countdown latch for the success callback
        doAnswer((InvocationOnMock invocationOnMock) -> {
                mSuccessLatch.countDown();
                return null;
            }).when(mCallback).onSuccess(mTask);
    }

    public void tearDown() {
        mHandlerThread.quitSafely();
    }

    @SmallTest
    public void testSuccess() throws Exception {
        // GIVEN that starting the user succeeds
        doAnswer((InvocationOnMock invocationOnMock) -> {
                mStartInBackgroundLatch.countDown();
                return true;
            }).when(mIActivityManager).startUserInBackground(TEST_USER_ID);

        // WHEN the task is run (on a handler thread to avoid deadlocks)
        new Handler(mHandlerThread.getLooper()).post(() -> mTask.run(TEST_USER_ID));

        // THEN user unlock should have been called
        assertTrue(mStartInBackgroundLatch.await(1, TimeUnit.SECONDS));

        // THEN an unlock receiver should be registered
        verify(mContext).registerReceiverAsUser(
                mReceiverCaptor.capture(),
                eq(UserHandle.of(TEST_USER_ID)),
                eq(StartManagedProfileTask.UNLOCK_FILTER),
                eq(null), eq(null));

        // THEN the success callback should not have been called
        verifyZeroInteractions(mCallback);

        // WHEN the unlock broadcast is sent
        mReceiverCaptor.getValue().onReceive(mContext, UNLOCK_INTENT);

        // THEN the success callback should be called
        assertTrue(mSuccessLatch.await(1, TimeUnit.SECONDS));
        verify(mCallback).onSuccess(mTask);
        verifyNoMoreInteractions(mCallback);

        verify(mContext).unregisterReceiver(mReceiverCaptor.getValue());
    }

    @SmallTest
    public void testError() throws Exception {
        // GIVEN that starting the user in background fails
        when(mIActivityManager.startUserInBackground(TEST_USER_ID)).thenReturn(false);

        // WHEN the task is run
        mTask.run(TEST_USER_ID);

        // THEN an unlock receiver should be registered
        verify(mContext).registerReceiverAsUser(
                mReceiverCaptor.capture(),
                eq(UserHandle.of(TEST_USER_ID)),
                eq(StartManagedProfileTask.UNLOCK_FILTER),
                eq(null), eq(null));

        // THEN the error callback should have been called
        verify(mCallback).onError(mTask, 0);
        verifyNoMoreInteractions(mCallback);

        verify(mContext).unregisterReceiver(mReceiverCaptor.getValue());
    }

    @SmallTest
    public void testRemoteException() throws Exception {
        // GIVEN that starting the user in background throws a remote exception
        when(mIActivityManager.startUserInBackground(TEST_USER_ID))
                .thenThrow(new RemoteException());

        // WHEN the task is run
        mTask.run(TEST_USER_ID);

        // THEN an unlock receiver should be registered
        verify(mContext).registerReceiverAsUser(
                mReceiverCaptor.capture(),
                eq(UserHandle.of(TEST_USER_ID)),
                eq(StartManagedProfileTask.UNLOCK_FILTER),
                eq(null), eq(null));

        // THEN the error callback should have been called
        verify(mCallback).onError(mTask, 0);
        verifyNoMoreInteractions(mCallback);

        verify(mContext).unregisterReceiver(mReceiverCaptor.getValue());
    }
}