Home | History | Annotate | Download | only in task 
      1 /*
      2  * Copyright (C) 2015 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 com.android.managedprovisioning.task;
     18 
     19 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE;
     20 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE;
     21 import static org.mockito.ArgumentMatchers.anyInt;
     22 import static org.mockito.ArgumentMatchers.eq;
     23 import static org.mockito.Mockito.never;
     24 import static org.mockito.Mockito.verify;
     25 import static org.mockito.Mockito.verifyNoMoreInteractions;
     26 import static org.mockito.Mockito.when;
     27 
     28 import android.app.admin.DevicePolicyManager;
     29 import android.content.ComponentName;
     30 import android.content.Context;
     31 import android.content.pm.PackageManager;
     32 import android.test.AndroidTestCase;
     33 import android.test.suitebuilder.annotation.SmallTest;
     34 
     35 import com.android.managedprovisioning.R;
     36 import com.android.managedprovisioning.common.Utils;
     37 import com.android.managedprovisioning.model.ProvisioningParams;
     38 
     39 import org.mockito.Mock;
     40 import org.mockito.MockitoAnnotations;
     41 
     42 public class SetDevicePolicyTaskTest extends AndroidTestCase {
     43     private static final String ADMIN_PACKAGE_NAME = "com.admin.test";
     44     private static final String ADMIN_RECEIVER_NAME = ADMIN_PACKAGE_NAME + ".AdminReceiver";
     45     private static final ComponentName ADMIN_COMPONENT_NAME = new ComponentName(ADMIN_PACKAGE_NAME,
     46             ADMIN_RECEIVER_NAME);
     47     private static final int TEST_USER_ID = 123;
     48 
     49     @Mock private Context mContext;
     50     @Mock private PackageManager mPackageManager;
     51     @Mock private DevicePolicyManager mDevicePolicyManager;
     52     @Mock private AbstractProvisioningTask.Callback mCallback;
     53     @Mock private Utils mUtils;
     54 
     55     private String mDefaultOwnerName;
     56     private SetDevicePolicyTask mTask;
     57 
     58     @Override
     59     protected void setUp() throws Exception {
     60         super.setUp();
     61         // This is necessary for mockito to work
     62         System.setProperty("dexmaker.dexcache", getContext().getCacheDir().toString());
     63         MockitoAnnotations.initMocks(this);
     64 
     65         mDefaultOwnerName = getContext().getResources()
     66                 .getString(R.string.default_owned_device_username);
     67 
     68         when(mContext.getPackageManager()).thenReturn(mPackageManager);
     69         when(mContext.getSystemService(Context.DEVICE_POLICY_SERVICE))
     70                 .thenReturn(mDevicePolicyManager);
     71         when(mContext.getResources()).thenReturn(getContext().getResources());
     72 
     73         when(mPackageManager.getApplicationEnabledSetting(ADMIN_PACKAGE_NAME))
     74                 .thenReturn(PackageManager.COMPONENT_ENABLED_STATE_DEFAULT);
     75         when(mDevicePolicyManager.getDeviceOwnerComponentOnCallingUser()).thenReturn(null);
     76         when(mDevicePolicyManager.setDeviceOwner(ADMIN_COMPONENT_NAME, mDefaultOwnerName,
     77                 TEST_USER_ID)).thenReturn(true);
     78         when(mUtils.findDeviceAdmin(null, ADMIN_COMPONENT_NAME, mContext, TEST_USER_ID))
     79                 .thenReturn(ADMIN_COMPONENT_NAME);
     80     }
     81 
     82     @SmallTest
     83     public void testEnableDevicePolicyApp_DefaultToDefault() {
     84         // GIVEN that we are provisioning device owner
     85         createTask(ACTION_PROVISION_MANAGED_DEVICE);
     86         // GIVEN that the management app is currently the manifest default
     87         when(mPackageManager.getApplicationEnabledSetting(ADMIN_PACKAGE_NAME))
     88                 .thenReturn(PackageManager.COMPONENT_ENABLED_STATE_DEFAULT);
     89 
     90         // WHEN running the task
     91         mTask.run(TEST_USER_ID);
     92 
     93         // THEN the management app should still be default
     94         verify(mPackageManager, never()).setApplicationEnabledSetting(eq(ADMIN_PACKAGE_NAME),
     95                 anyInt(), anyInt());
     96         verify(mCallback).onSuccess(mTask);
     97         verifyNoMoreInteractions(mCallback);
     98     }
     99 
    100     @SmallTest
    101     public void testEnableDevicePolicyApp_DisabledToDefault() {
    102         // GIVEN that we are provisioning device owner
    103         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    104         // GIVEN that the management app is currently disabled
    105         when(mPackageManager.getApplicationEnabledSetting(ADMIN_PACKAGE_NAME))
    106                 .thenReturn(PackageManager.COMPONENT_ENABLED_STATE_DISABLED);
    107 
    108         // WHEN running the task
    109         mTask.run(TEST_USER_ID);
    110 
    111         // THEN the management app should have been enabled
    112         verify(mPackageManager).setApplicationEnabledSetting(ADMIN_PACKAGE_NAME,
    113                 PackageManager.COMPONENT_ENABLED_STATE_DEFAULT,
    114                 PackageManager.DONT_KILL_APP);
    115         verify(mCallback).onSuccess(mTask);
    116         verifyNoMoreInteractions(mCallback);
    117     }
    118 
    119     @SmallTest
    120     public void testEnableDevicePolicyApp_EnabledToEnabled() {
    121         // GIVEN that we are provisioning device owner
    122         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    123         // GIVEN that the management app is currently enabled
    124         when(mPackageManager.getApplicationEnabledSetting(ADMIN_PACKAGE_NAME))
    125                 .thenReturn(PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
    126 
    127         // WHEN running the task
    128         mTask.run(TEST_USER_ID);
    129 
    130         // THEN the management app should have been untouched
    131         verify(mPackageManager, never()).setApplicationEnabledSetting(eq(ADMIN_PACKAGE_NAME),
    132                 anyInt(), anyInt());
    133         verify(mCallback).onSuccess(mTask);
    134         verifyNoMoreInteractions(mCallback);
    135     }
    136 
    137     @SmallTest
    138     public void testEnableDevicePolicyApp_PackageNotFound() {
    139         // GIVEN that we are provisioning device owner
    140         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    141         // GIVEN that the management app is not present on the device
    142         when(mPackageManager.getApplicationEnabledSetting(ADMIN_PACKAGE_NAME))
    143                 .thenThrow(new IllegalArgumentException());
    144 
    145         // WHEN running the task
    146         mTask.run(TEST_USER_ID);
    147 
    148         // THEN an error should be returned
    149         verify(mCallback).onError(mTask, 0);
    150         verifyNoMoreInteractions(mCallback);
    151     }
    152 
    153     @SmallTest
    154     public void testSetActiveAdmin() {
    155         // GIVEN that we are provisioning device owner
    156         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    157 
    158         // WHEN running the task
    159         mTask.run(TEST_USER_ID);
    160 
    161         // THEN the management app should have been set as active admin
    162         verify(mDevicePolicyManager).setActiveAdmin(ADMIN_COMPONENT_NAME, true, TEST_USER_ID);
    163         verify(mCallback).onSuccess(mTask);
    164         verifyNoMoreInteractions(mCallback);
    165     }
    166 
    167     @SmallTest
    168     public void testSetDeviceOwner() {
    169         // GIVEN that we are provisioning device owner
    170         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    171 
    172         // WHEN running the task
    173         mTask.run(TEST_USER_ID);
    174 
    175         // THEN the management app should have been set as device owner
    176         verify(mDevicePolicyManager).setDeviceOwner(ADMIN_COMPONENT_NAME, mDefaultOwnerName,
    177                 TEST_USER_ID);
    178         verify(mCallback).onSuccess(mTask);
    179         verifyNoMoreInteractions(mCallback);
    180     }
    181 
    182     @SmallTest
    183     public void testSetDeviceOwner_PreconditionsNotMet() {
    184         // GIVEN that we are provisioning device owner
    185         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    186 
    187         // GIVEN that setting device owner is not currently allowed
    188         when(mDevicePolicyManager.setDeviceOwner(ADMIN_COMPONENT_NAME, mDefaultOwnerName,
    189                 TEST_USER_ID)).thenThrow(new IllegalStateException());
    190 
    191         // WHEN running the task
    192         mTask.run(TEST_USER_ID);
    193 
    194         // THEN an error should be returned
    195         verify(mCallback).onError(mTask, 0);
    196         verifyNoMoreInteractions(mCallback);
    197     }
    198 
    199     @SmallTest
    200     public void testSetDeviceOwner_ReturnFalse() {
    201         // GIVEN that we are provisioning device owner
    202         createTask(ACTION_PROVISION_MANAGED_DEVICE);
    203 
    204         // GIVEN that setting device owner fails
    205         when(mDevicePolicyManager.setDeviceOwner(ADMIN_COMPONENT_NAME, mDefaultOwnerName,
    206                 TEST_USER_ID)).thenReturn(false);
    207 
    208         // WHEN running the task
    209         mTask.run(TEST_USER_ID);
    210 
    211         // THEN an error should be returned
    212         verify(mCallback).onError(mTask, 0);
    213         verifyNoMoreInteractions(mCallback);
    214     }
    215 
    216     @SmallTest
    217     public void testSetProfileOwner() {
    218         // GIVEN that we are provisioning a managed profile
    219         createTask(ACTION_PROVISION_MANAGED_PROFILE);
    220         // GIVEN that setting the profile owner succeeds
    221         when(mDevicePolicyManager.setProfileOwner(ADMIN_COMPONENT_NAME, ADMIN_PACKAGE_NAME,
    222                 TEST_USER_ID)).thenReturn(true);
    223 
    224         // WHEN running the task
    225         mTask.run(TEST_USER_ID);
    226 
    227         // THEN the management app should have been set as profile owner
    228         verify(mDevicePolicyManager).setProfileOwner(ADMIN_COMPONENT_NAME, ADMIN_PACKAGE_NAME,
    229                 TEST_USER_ID);
    230         verify(mCallback).onSuccess(mTask);
    231         verifyNoMoreInteractions(mCallback);
    232     }
    233 
    234     private void createTask(String action) {
    235         ProvisioningParams params = new ProvisioningParams.Builder()
    236                 .setDeviceAdminComponentName(ADMIN_COMPONENT_NAME)
    237                 .setProvisioningAction(action)
    238                 .build();
    239         mTask = new SetDevicePolicyTask(mUtils, mContext, params, mCallback);
    240     }
    241 }
    242