1 /* 2 * Copyright (C) 2021 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 21 import static com.google.common.truth.Truth.assertThat; 22 23 import static org.mockito.ArgumentMatchers.anyInt; 24 import static org.mockito.Matchers.any; 25 import static org.mockito.Mockito.doThrow; 26 import static org.mockito.Mockito.mock; 27 import static org.mockito.Mockito.verify; 28 import static org.mockito.Mockito.verifyNoMoreInteractions; 29 import static org.mockito.Mockito.when; 30 31 import android.app.admin.DevicePolicyManager; 32 import android.app.admin.FullyManagedDeviceProvisioningParams; 33 import android.app.admin.ProvisioningException; 34 import android.content.ComponentName; 35 import android.content.Context; 36 import android.content.res.Resources; 37 38 import androidx.test.filters.SmallTest; 39 40 import com.android.managedprovisioning.analytics.ProvisioningAnalyticsTracker; 41 import com.android.managedprovisioning.common.Utils; 42 import com.android.managedprovisioning.model.ProvisioningParams; 43 44 import org.junit.Before; 45 import org.junit.Test; 46 import org.junit.runner.RunWith; 47 import org.junit.runners.JUnit4; 48 import org.mockito.ArgumentCaptor; 49 import org.mockito.Captor; 50 import org.mockito.Mock; 51 import org.mockito.MockitoAnnotations; 52 53 /** 54 * Unit tests for {@link ProvisionFullyManagedDeviceTask}. 55 */ 56 @SmallTest 57 @RunWith(JUnit4.class) 58 public class ProvisionFullyManagedDeviceTaskTest { 59 private static final int TEST_USER_ID = 111; 60 private static final String TEST_DPC_PACKAGE_NAME = "com.test.dpc"; 61 private static final String OWNER_NAME = "ownerName"; 62 private static final ComponentName ADMIN = new ComponentName( 63 TEST_DPC_PACKAGE_NAME, ".Receiver"); 64 private static final ProvisioningParams TEST_PARAMS = new ProvisioningParams.Builder() 65 .setDeviceAdminComponentName(ADMIN) 66 .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE) 67 .build(); 68 69 @Mock private Context mContext; 70 @Mock private DevicePolicyManager mDevicePolicyManager; 71 @Mock private AbstractProvisioningTask.Callback mCallback; 72 @Mock private Utils mUtils; 73 @Mock private Resources mResources; 74 75 @Captor private ArgumentCaptor<FullyManagedDeviceProvisioningParams> mParamsCaptor; 76 77 private static final String TEST_ERROR_MESSAGE = "test error message"; 78 private static final ProvisioningException PROVISIONING_EXCEPTION = new ProvisioningException( 79 new Exception(), /* provisioningError= */ 0, TEST_ERROR_MESSAGE); 80 81 @Before setUp()82 public void setUp() throws Exception { 83 MockitoAnnotations.initMocks(this); 84 when(mContext.getSystemServiceName(DevicePolicyManager.class)) 85 .thenReturn(Context.DEVICE_POLICY_SERVICE); 86 when(mContext.getSystemService(DevicePolicyManager.class)) 87 .thenReturn(mDevicePolicyManager); 88 when(mContext.getResources()).thenReturn(mResources); 89 when(mResources.getString(anyInt())).thenReturn(OWNER_NAME); 90 when(mUtils.findDeviceAdmin(TEST_DPC_PACKAGE_NAME, ADMIN, mContext, TEST_USER_ID)) 91 .thenReturn(ADMIN); 92 } 93 94 @Test testSuccess()95 public void testSuccess() { 96 ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS); 97 98 task.run(TEST_USER_ID); 99 100 verify(mCallback).onSuccess(task); 101 verifyNoMoreInteractions(mCallback); 102 } 103 104 @Test testError()105 public void testError() throws Exception { 106 ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS); 107 doThrow(createProvisioningException()).when(mDevicePolicyManager) 108 .provisionFullyManagedDevice(any()); 109 110 task.run(TEST_USER_ID); 111 112 verify(mCallback).onError(task, 0, /* errorMessage= */ null); 113 verifyNoMoreInteractions(mCallback); 114 } 115 116 @Test testTextError()117 public void testTextError() throws Exception { 118 ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS); 119 doThrow(PROVISIONING_EXCEPTION) 120 .when(mDevicePolicyManager).provisionFullyManagedDevice(any()); 121 122 task.run(TEST_USER_ID); 123 124 verify(mCallback).onError(task, 0, TEST_ERROR_MESSAGE); 125 verifyNoMoreInteractions(mCallback); 126 } 127 128 @Test testCanGrantSensorsPermissionsByDefault()129 public void testCanGrantSensorsPermissionsByDefault() throws ProvisioningException { 130 ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS); 131 132 task.run(TEST_USER_ID); 133 134 verify(mCallback).onSuccess(task); 135 verifyNoMoreInteractions(mCallback); 136 verify(mDevicePolicyManager).provisionFullyManagedDevice(mParamsCaptor.capture()); 137 FullyManagedDeviceProvisioningParams capturedParams = mParamsCaptor.getValue(); 138 assertThat(capturedParams.canDeviceOwnerGrantSensorsPermissions()).isTrue(); 139 } 140 141 @Test testCanOptOutOfGrantingSensorsPermissions()142 public void testCanOptOutOfGrantingSensorsPermissions() throws ProvisioningException { 143 final ProvisioningParams testParams = new ProvisioningParams.Builder() 144 .setDeviceAdminComponentName(ADMIN) 145 .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE) 146 .setDeviceOwnerPermissionGrantOptOut(true) 147 .build(); 148 ProvisionFullyManagedDeviceTask task = createProvisioningTask(testParams); 149 150 task.run(TEST_USER_ID); 151 152 verify(mCallback).onSuccess(task); 153 verifyNoMoreInteractions(mCallback); 154 verify(mDevicePolicyManager).provisionFullyManagedDevice(mParamsCaptor.capture()); 155 FullyManagedDeviceProvisioningParams capturedParams = mParamsCaptor.getValue(); 156 assertThat(capturedParams.canDeviceOwnerGrantSensorsPermissions()).isFalse(); 157 } 158 159 createProvisioningTask(ProvisioningParams params)160 private ProvisionFullyManagedDeviceTask createProvisioningTask(ProvisioningParams params) { 161 return new ProvisionFullyManagedDeviceTask( 162 mUtils, 163 mContext, 164 params, 165 mCallback, 166 mock(ProvisioningAnalyticsTracker.class)); 167 } 168 createProvisioningException()169 private ProvisioningException createProvisioningException() { 170 return new ProvisioningException( 171 new Exception(), 172 ProvisioningException.ERROR_PRE_CONDITION_FAILED); 173 } 174 } 175