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 setUp()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 testEnableDevicePolicyApp_DefaultToDefault()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 testEnableDevicePolicyApp_DisabledToDefault()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 testEnableDevicePolicyApp_EnabledToEnabled()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 testEnableDevicePolicyApp_PackageNotFound()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 testSetActiveAdmin()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 testSetDeviceOwner()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 testSetDeviceOwner_PreconditionsNotMet()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 testSetDeviceOwner_ReturnFalse()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 testSetProfileOwner()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 createTask(String action)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