Home | History | Annotate | Download | only in cts 
      1 /*
      2  * Copyright (C) 2013 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 
     17 package android.admin.cts;
     18 
     19 import android.app.Activity;
     20 import android.app.admin.DevicePolicyManager;
     21 import android.content.ComponentName;
     22 import android.content.Context;
     23 import android.content.Intent;
     24 import android.content.pm.PackageManager;
     25 import android.admin.app.CtsDeviceAdminBrokenReceiver;
     26 import android.admin.app.CtsDeviceAdminBrokenReceiver2;
     27 import android.admin.app.CtsDeviceAdminBrokenReceiver3;
     28 import android.admin.app.CtsDeviceAdminBrokenReceiver4;
     29 import android.admin.app.CtsDeviceAdminBrokenReceiver5;
     30 import android.admin.app.CtsDeviceAdminDeactivatedReceiver;
     31 import android.admin.app.CtsDeviceAdminActivationTestActivity;
     32 import android.admin.app.CtsDeviceAdminActivationTestActivity.OnActivityResultListener;
     33 import android.os.SystemClock;
     34 import android.test.ActivityInstrumentationTestCase2;
     35 import android.util.Log;
     36 
     37 import org.mockito.ArgumentCaptor;
     38 import org.mockito.Mock;
     39 import org.mockito.Mockito;
     40 import org.mockito.MockitoAnnotations;
     41 
     42 /**
     43  * Tests for the standard way of activating a Device Admin: by starting system UI via an
     44  * {@link Intent} with {@link DevicePolicyManager#ACTION_ADD_DEVICE_ADMIN}. The test requires that
     45  * the {@code CtsDeviceAdmin.apk} be installed.
     46  */
     47 public class DeviceAdminActivationTest
     48     extends ActivityInstrumentationTestCase2<CtsDeviceAdminActivationTestActivity> {
     49 
     50     private static final String TAG = DeviceAdminActivationTest.class.getSimpleName();
     51 
     52     // IMPLEMENTATION NOTE: Because Device Admin activation requires the use of
     53     // Activity.startActivityForResult, this test creates an empty Activity which then invokes
     54     // startActivityForResult.
     55 
     56     private static final int REQUEST_CODE_ACTIVATE_ADMIN = 1;
     57 
     58     /**
     59      * Maximum duration of time (milliseconds) after which the effects of programmatic actions in
     60      * this test should have affected the UI.
     61      */
     62     private static final int UI_EFFECT_TIMEOUT_MILLIS = 5000;
     63 
     64     private boolean mDeviceAdmin;
     65     @Mock private OnActivityResultListener mMockOnActivityResultListener;
     66 
     67     public DeviceAdminActivationTest() {
     68         super(CtsDeviceAdminActivationTestActivity.class);
     69     }
     70 
     71     @Override
     72     protected void setUp() throws Exception {
     73         super.setUp();
     74         MockitoAnnotations.initMocks(this);
     75         getActivity().setOnActivityResultListener(mMockOnActivityResultListener);
     76         mDeviceAdmin = getInstrumentation().getContext().getPackageManager().hasSystemFeature(
     77                 PackageManager.FEATURE_DEVICE_ADMIN);
     78     }
     79 
     80     @Override
     81     protected void tearDown() throws Exception {
     82         try {
     83             finishActivateDeviceAdminActivity();
     84         } finally {
     85             super.tearDown();
     86         }
     87     }
     88 
     89     public void testActivateGoodReceiverDisplaysActivationUi() throws Exception {
     90         if (!mDeviceAdmin) {
     91             Log.w(TAG, "Skipping testActivateGoodReceiverDisplaysActivationUi");
     92             return;
     93         }
     94         assertDeviceAdminDeactivated(CtsDeviceAdminDeactivatedReceiver.class);
     95         startAddDeviceAdminActivityForResult(CtsDeviceAdminDeactivatedReceiver.class);
     96         assertWithTimeoutOnActivityResultNotInvoked();
     97         // The UI is up and running. Assert that dismissing the UI returns the corresponding result
     98         // to the test activity.
     99         finishActivateDeviceAdminActivity();
    100         assertWithTimeoutOnActivityResultInvokedWithResultCode(Activity.RESULT_CANCELED);
    101         assertDeviceAdminDeactivated(CtsDeviceAdminDeactivatedReceiver.class);
    102     }
    103 
    104     public void testActivateBrokenReceiverFails() throws Exception {
    105         if (!mDeviceAdmin) {
    106             Log.w(TAG, "Skipping testActivateBrokenReceiverFails");
    107             return;
    108         }
    109         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver.class);
    110         startAddDeviceAdminActivityForResult(CtsDeviceAdminBrokenReceiver.class);
    111         assertWithTimeoutOnActivityResultInvokedWithResultCode(Activity.RESULT_CANCELED);
    112         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver.class);
    113     }
    114 
    115     public void testActivateBrokenReceiver2Fails() throws Exception {
    116         if (!mDeviceAdmin) {
    117             Log.w(TAG, "Skipping testActivateBrokenReceiver2Fails");
    118             return;
    119         }
    120         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver2.class);
    121         startAddDeviceAdminActivityForResult(CtsDeviceAdminBrokenReceiver2.class);
    122         assertWithTimeoutOnActivityResultInvokedWithResultCode(Activity.RESULT_CANCELED);
    123         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver2.class);
    124     }
    125 
    126     public void testActivateBrokenReceiver3Fails() throws Exception {
    127         if (!mDeviceAdmin) {
    128             Log.w(TAG, "Skipping testActivateBrokenReceiver3Fails");
    129             return;
    130         }
    131         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver3.class);
    132         startAddDeviceAdminActivityForResult(CtsDeviceAdminBrokenReceiver3.class);
    133         assertWithTimeoutOnActivityResultInvokedWithResultCode(Activity.RESULT_CANCELED);
    134         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver3.class);
    135     }
    136 
    137     public void testActivateBrokenReceiver4Fails() throws Exception {
    138         if (!mDeviceAdmin) {
    139             Log.w(TAG, "Skipping testActivateBrokenReceiver4Fails");
    140             return;
    141         }
    142         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver4.class);
    143         startAddDeviceAdminActivityForResult(CtsDeviceAdminBrokenReceiver4.class);
    144         assertWithTimeoutOnActivityResultInvokedWithResultCode(Activity.RESULT_CANCELED);
    145         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver4.class);
    146     }
    147 
    148     public void testActivateBrokenReceiver5Fails() throws Exception {
    149         if (!mDeviceAdmin) {
    150             Log.w(TAG, "Skipping testActivateBrokenReceiver5Fails");
    151             return;
    152         }
    153         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver5.class);
    154         startAddDeviceAdminActivityForResult(CtsDeviceAdminBrokenReceiver5.class);
    155         assertWithTimeoutOnActivityResultInvokedWithResultCode(Activity.RESULT_CANCELED);
    156         assertDeviceAdminDeactivated(CtsDeviceAdminBrokenReceiver5.class);
    157     }
    158 
    159     private void startAddDeviceAdminActivityForResult(Class<?> receiverClass) {
    160         getActivity().startActivityForResult(
    161                 getAddDeviceAdminIntent(receiverClass),
    162                 REQUEST_CODE_ACTIVATE_ADMIN);
    163     }
    164 
    165     private Intent getAddDeviceAdminIntent(Class<?> receiverClass) {
    166         return new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN)
    167             .putExtra(
    168                     DevicePolicyManager.EXTRA_DEVICE_ADMIN,
    169                     new ComponentName(
    170                             getInstrumentation().getTargetContext(),
    171                             receiverClass));
    172     }
    173 
    174     private void assertWithTimeoutOnActivityResultNotInvoked() {
    175         SystemClock.sleep(UI_EFFECT_TIMEOUT_MILLIS);
    176         Mockito.verify(mMockOnActivityResultListener, Mockito.never())
    177                 .onActivityResult(
    178                         Mockito.eq(REQUEST_CODE_ACTIVATE_ADMIN),
    179                         Mockito.anyInt(),
    180                         Mockito.nullable(Intent.class));
    181     }
    182 
    183     private void assertWithTimeoutOnActivityResultInvokedWithResultCode(int expectedResultCode) {
    184         ArgumentCaptor<Integer> resultCodeCaptor = ArgumentCaptor.forClass(int.class);
    185         Mockito.verify(mMockOnActivityResultListener, Mockito.timeout(UI_EFFECT_TIMEOUT_MILLIS))
    186                 .onActivityResult(
    187                         Mockito.eq(REQUEST_CODE_ACTIVATE_ADMIN),
    188                         resultCodeCaptor.capture(),
    189                         Mockito.nullable(Intent.class));
    190         assertEquals(expectedResultCode, (int) resultCodeCaptor.getValue());
    191     }
    192 
    193     private void finishActivateDeviceAdminActivity() {
    194         getActivity().finishActivity(REQUEST_CODE_ACTIVATE_ADMIN);
    195     }
    196 
    197     private void assertDeviceAdminDeactivated(Class<?> receiverClass) {
    198         DevicePolicyManager devicePolicyManager =
    199                 (DevicePolicyManager) getActivity().getSystemService(
    200                         Context.DEVICE_POLICY_SERVICE);
    201         assertFalse(devicePolicyManager.isAdminActive(
    202                 new ComponentName(getInstrumentation().getTargetContext(), receiverClass)));
    203     }
    204 }
    205