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 import com.android.managedprovisioning.task.nonrequiredapps.SystemAppsSnapshot;
44 
45 import org.junit.Before;
46 import org.junit.Test;
47 import org.junit.runner.RunWith;
48 import org.junit.runners.JUnit4;
49 import org.mockito.ArgumentCaptor;
50 import org.mockito.Captor;
51 import org.mockito.Mock;
52 import org.mockito.MockitoAnnotations;
53 
54 /**
55  * Unit tests for {@link ProvisionFullyManagedDeviceTask}.
56  */
57 @SmallTest
58 @RunWith(JUnit4.class)
59 public class ProvisionFullyManagedDeviceTaskTest {
60     private static final int TEST_USER_ID = 111;
61     private static final String TEST_DPC_PACKAGE_NAME = "com.test.dpc";
62     private static final String OWNER_NAME = "ownerName";
63     private static final ComponentName ADMIN = new ComponentName(
64             TEST_DPC_PACKAGE_NAME, ".Receiver");
65     private static final ProvisioningParams TEST_PARAMS = new ProvisioningParams.Builder()
66             .setDeviceAdminComponentName(ADMIN)
67             .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE)
68             .build();
69     private static final ProvisioningParams TEST_PARAMS_LEAVE_SYSTEM_APPS =
70             new ProvisioningParams.Builder()
71                     .setDeviceAdminComponentName(ADMIN)
72                     .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE)
73                     .setLeaveAllSystemAppsEnabled(true)
74                     .build();
75 
76     @Mock private Context mContext;
77     @Mock private DevicePolicyManager mDevicePolicyManager;
78     @Mock private SystemAppsSnapshot mSystemAppsSnapshot;
79     @Mock private AbstractProvisioningTask.Callback mCallback;
80     @Mock private Utils mUtils;
81     @Mock private Resources mResources;
82 
83     @Captor private ArgumentCaptor<FullyManagedDeviceProvisioningParams> mParamsCaptor;
84 
85     @Before
setUp()86     public void setUp() throws Exception {
87         MockitoAnnotations.initMocks(this);
88         when(mContext.getSystemServiceName(DevicePolicyManager.class))
89                 .thenReturn(Context.DEVICE_POLICY_SERVICE);
90         when(mContext.getSystemService(DevicePolicyManager.class))
91                 .thenReturn(mDevicePolicyManager);
92         when(mContext.getResources()).thenReturn(mResources);
93         when(mResources.getString(anyInt())).thenReturn(OWNER_NAME);
94         when(mUtils.findDeviceAdmin(TEST_DPC_PACKAGE_NAME, ADMIN, mContext, TEST_USER_ID))
95                 .thenReturn(ADMIN);
96     }
97 
98     @Test
testSuccess()99     public void testSuccess() {
100         ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS);
101 
102         task.run(TEST_USER_ID);
103 
104         verify(mCallback).onSuccess(task);
105         verifyNoMoreInteractions(mCallback);
106         verify(mSystemAppsSnapshot).takeNewSnapshot(TEST_USER_ID);
107     }
108 
109     @Test
testError()110     public void testError() throws Exception {
111         ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS);
112         doThrow(createProvisioningException()).when(mDevicePolicyManager)
113                 .provisionFullyManagedDevice(any());
114 
115         task.run(TEST_USER_ID);
116 
117         verify(mCallback).onError(task, 0);
118         verifyNoMoreInteractions(mCallback);
119         verifyNoMoreInteractions(mSystemAppsSnapshot);
120     }
121 
122     @Test
testLeaveSystemAppsEnabled()123     public void testLeaveSystemAppsEnabled() {
124         ProvisionFullyManagedDeviceTask task = createProvisioningTask(
125                 TEST_PARAMS_LEAVE_SYSTEM_APPS);
126 
127         task.run(TEST_USER_ID);
128 
129         verify(mCallback).onSuccess(task);
130         verifyNoMoreInteractions(mCallback);
131         verifyNoMoreInteractions(mSystemAppsSnapshot);
132     }
133 
134     @Test
testCanGrantSensorsPermissionsByDefault()135     public void testCanGrantSensorsPermissionsByDefault() throws ProvisioningException {
136         ProvisionFullyManagedDeviceTask task = createProvisioningTask(TEST_PARAMS);
137 
138         task.run(TEST_USER_ID);
139 
140         verify(mCallback).onSuccess(task);
141         verifyNoMoreInteractions(mCallback);
142         verify(mSystemAppsSnapshot).takeNewSnapshot(TEST_USER_ID);
143         verify(mDevicePolicyManager).provisionFullyManagedDevice(mParamsCaptor.capture());
144         FullyManagedDeviceProvisioningParams capturedParams = mParamsCaptor.getValue();
145         assertThat(capturedParams.canDeviceOwnerGrantSensorsPermissions()).isTrue();
146     }
147 
148     @Test
testCanOptOutOfGrantingSensorsPermissions()149     public void testCanOptOutOfGrantingSensorsPermissions() throws ProvisioningException {
150         final ProvisioningParams testParams = new ProvisioningParams.Builder()
151                 .setDeviceAdminComponentName(ADMIN)
152                 .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE)
153                 .setDeviceOwnerPermissionGrantOptOut(true)
154                 .build();
155         ProvisionFullyManagedDeviceTask task = createProvisioningTask(testParams);
156 
157         task.run(TEST_USER_ID);
158 
159         verify(mCallback).onSuccess(task);
160         verifyNoMoreInteractions(mCallback);
161         verify(mSystemAppsSnapshot).takeNewSnapshot(TEST_USER_ID);
162         verify(mDevicePolicyManager).provisionFullyManagedDevice(mParamsCaptor.capture());
163         FullyManagedDeviceProvisioningParams capturedParams = mParamsCaptor.getValue();
164         assertThat(capturedParams.canDeviceOwnerGrantSensorsPermissions()).isFalse();
165     }
166 
167 
createProvisioningTask(ProvisioningParams params)168     private ProvisionFullyManagedDeviceTask createProvisioningTask(ProvisioningParams params) {
169         return new ProvisionFullyManagedDeviceTask(
170                 mUtils,
171                 mContext,
172                 mSystemAppsSnapshot,
173                 params,
174                 mCallback,
175                 mock(ProvisioningAnalyticsTracker.class));
176     }
177 
createProvisioningException()178     private ProvisioningException createProvisioningException() {
179         return new ProvisioningException(
180                 new Exception(),
181                 DevicePolicyManager.PROVISIONING_RESULT_PRE_CONDITION_FAILED);
182     }
183 }
184