1 /*
2  * Copyright 2016, 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.finalization;
18 
19 import static android.app.admin.DeviceAdminInfo.HEADLESS_DEVICE_OWNER_MODE_AFFILIATED;
20 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE;
21 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE;
22 import static android.app.admin.DevicePolicyManager.STATE_USER_PROFILE_COMPLETE;
23 import static android.app.admin.DevicePolicyManager.STATE_USER_PROFILE_FINALIZED;
24 import static android.app.admin.DevicePolicyManager.STATE_USER_SETUP_COMPLETE;
25 import static android.app.admin.DevicePolicyManager.STATE_USER_SETUP_FINALIZED;
26 import static android.app.admin.DevicePolicyManager.STATE_USER_SETUP_INCOMPLETE;
27 import static android.app.admin.DevicePolicyManager.STATE_USER_UNMANAGED;
28 import static android.content.Context.DEVICE_POLICY_SERVICE;
29 
30 import static org.mockito.Mockito.anyInt;
31 import static org.mockito.Mockito.never;
32 import static org.mockito.Mockito.verify;
33 import static org.mockito.Mockito.when;
34 
35 import android.app.admin.DevicePolicyManager;
36 import android.content.Context;
37 import android.os.UserHandle;
38 import android.test.AndroidTestCase;
39 
40 import androidx.test.filters.SmallTest;
41 
42 import com.android.managedprovisioning.common.SettingsFacade;
43 import com.android.managedprovisioning.common.Utils;
44 import com.android.managedprovisioning.model.ProvisioningParams;
45 
46 import org.mockito.Mock;
47 import org.mockito.MockitoAnnotations;
48 
49 /**
50  * Unit tests for {@link UserProvisioningStateHelper}.
51  */
52 public class UserProvisioningStateHelperTest extends AndroidTestCase {
53     private static final int SYSTEM_USER_ID = 0;
54     private static final int PRIMARY_USER_ID = 1;
55     private static final int MANAGED_PROFILE_USER_ID = 2;
56     private static final String TEST_MDM_PACKAGE_NAME = "mdm.package.name";
57 
58     @Mock private Context mContext;
59     @Mock private DevicePolicyManager mDevicePolicyManager;
60     @Mock private Utils mUtils;
61     @Mock private SettingsFacade mSettingsFacade;
62 
63     private UserProvisioningStateHelper mHelper;
64 
setUp()65     public void setUp() {
66         // this is necessary for mockito to work
67         System.setProperty("dexmaker.dexcache", getContext().getCacheDir().toString());
68         MockitoAnnotations.initMocks(this);
69 
70         when(mContext.getSystemService(DEVICE_POLICY_SERVICE)).thenReturn(mDevicePolicyManager);
71 
72         mHelper = new UserProvisioningStateHelper(
73                 mContext,
74                 mUtils,
75                 mSettingsFacade,
76                 PRIMARY_USER_ID);
77     }
78 
79     @SmallTest
testInitiallyDone_ProfileAfterSuw()80     public void testInitiallyDone_ProfileAfterSuw() {
81         // GIVEN that we've provisioned a managed profile after SUW
82         final ProvisioningParams params =
83                 createProvisioningParams(ACTION_PROVISION_MANAGED_PROFILE);
84         markUserSetupCompleted(true);
85         when(mUtils.getManagedProfile(mContext)).thenReturn(UserHandle.of(MANAGED_PROFILE_USER_ID));
86 
87         // WHEN calling markUserProvisioningStateInitiallyDone
88         mHelper.markUserProvisioningStateInitiallyDone(params);
89 
90         // THEN the managed profile's state should be set to FINALIZED
91         verifyUserProvisioningStateSet(STATE_USER_SETUP_FINALIZED, MANAGED_PROFILE_USER_ID);
92     }
93 
94     @SmallTest
testInitiallyDone_ProfileDuringSuw()95     public void testInitiallyDone_ProfileDuringSuw() {
96         // GIVEN that we've provisioned a managed profile during SUW
97         final ProvisioningParams params =
98                 createProvisioningParams(ACTION_PROVISION_MANAGED_PROFILE);
99         markUserSetupCompleted(false);
100         when(mUtils.getManagedProfile(mContext)).thenReturn(UserHandle.of(MANAGED_PROFILE_USER_ID));
101 
102         // WHEN calling markUserProvisioningStateInitiallyDone
103         mHelper.markUserProvisioningStateInitiallyDone(params);
104 
105         // THEN the managed profile's state should be set to COMPLETE
106         verifyUserProvisioningStateSet(STATE_USER_SETUP_COMPLETE, MANAGED_PROFILE_USER_ID);
107         // THEN the primary user's state should be set to PROFILE_COMPLETE
108         verifyUserProvisioningStateSet(STATE_USER_PROFILE_COMPLETE, PRIMARY_USER_ID);
109     }
110 
111     @SmallTest
testInitiallyDone_DeviceAfterSuw()112     public void testInitiallyDone_DeviceAfterSuw() {
113         final ProvisioningParams params =
114                 createProvisioningParams(ACTION_PROVISION_MANAGED_DEVICE);
115         markUserSetupCompleted(true);
116 
117         mHelper.markUserProvisioningStateInitiallyDone(params);
118 
119         verify(mDevicePolicyManager, never()).setUserProvisioningState(anyInt(), anyInt());
120     }
121 
122     @SmallTest
testInitiallyDone_DeviceAfterSuw_allowedByParams()123     public void testInitiallyDone_DeviceAfterSuw_allowedByParams() {
124         final ProvisioningParams params =
125                 createProvisioningParams(ACTION_PROVISION_MANAGED_DEVICE)
126                         .toBuilder()
127                         .setAllowProvisioningAfterUserSetupComplete(true)
128                         .build();
129         markUserSetupCompleted(true);
130 
131         mHelper.markUserProvisioningStateInitiallyDone(params);
132 
133         verifyUserProvisioningStateSet(STATE_USER_SETUP_COMPLETE, PRIMARY_USER_ID);
134     }
135 
136     @SmallTest
testFinalized_ManagedProfile()137     public void testFinalized_ManagedProfile() {
138         // GIVEN that we've provisioned a managed profile
139         final ProvisioningParams params =
140                 createProvisioningParams(ACTION_PROVISION_MANAGED_PROFILE);
141         when(mUtils.getManagedProfile(mContext)).thenReturn(UserHandle.of(MANAGED_PROFILE_USER_ID));
142 
143         // WHEN calling markUserProvisioningStateFinalized
144         mHelper.markUserProvisioningStateFinalized(params);
145 
146         // THEN the managed profile's state should be set to FINALIZED
147         verifyUserProvisioningStateSet(STATE_USER_SETUP_FINALIZED, MANAGED_PROFILE_USER_ID);
148         // THEN the primary user's state should be set to STATE_USER_PROFILE_FINALIZED
149         verifyUserProvisioningStateSet(STATE_USER_PROFILE_FINALIZED, PRIMARY_USER_ID);
150     }
151 
152     @SmallTest
testFinalized_DeviceOwner()153     public void testFinalized_DeviceOwner() {
154         // GIVEN that we've provisioned a device owner with skip user setup false
155         final ProvisioningParams params = createProvisioningParams(ACTION_PROVISION_MANAGED_DEVICE);
156 
157         // WHEN calling markUserProvisioningStateFinalized
158         mHelper.markUserProvisioningStateFinalized(params);
159 
160         // THEN the primary user's state should be set to FINALIZED
161         verifyUserProvisioningStateSet(STATE_USER_SETUP_FINALIZED, PRIMARY_USER_ID);
162     }
163 
164     @SmallTest
testFinalized_DeviceOwner_HeadlessSystemUser()165     public void testFinalized_DeviceOwner_HeadlessSystemUser() {
166         setHeadlessSystemUserMode();
167         when(mDevicePolicyManager.getHeadlessDeviceOwnerMode())
168                 .thenReturn(HEADLESS_DEVICE_OWNER_MODE_AFFILIATED);
169 
170         // GIVEN that we've provisioned a device owner with skip user setup false
171         final ProvisioningParams params = createProvisioningParams(ACTION_PROVISION_MANAGED_DEVICE);
172 
173         // WHEN calling markUserProvisioningStateFinalized
174         mHelper.markUserProvisioningStateFinalized(params);
175 
176         // THEN both the user who is setting DO and the headless system user's states
177         // should be set to FINALIZED
178         verifyUserProvisioningStateSet(STATE_USER_SETUP_FINALIZED, PRIMARY_USER_ID);
179         verifyUserProvisioningStateSet(STATE_USER_SETUP_FINALIZED, SYSTEM_USER_ID);
180     }
181 
182 
183     @SmallTest
testIsStateUnmanagedOrFinalized()184     public void testIsStateUnmanagedOrFinalized() {
185         assertTrue(isStateUnmanagedOrFinalizedWithCurrentState(STATE_USER_UNMANAGED));
186         assertTrue(isStateUnmanagedOrFinalizedWithCurrentState(STATE_USER_SETUP_FINALIZED));
187         assertFalse(isStateUnmanagedOrFinalizedWithCurrentState(STATE_USER_PROFILE_COMPLETE));
188         assertFalse(isStateUnmanagedOrFinalizedWithCurrentState(STATE_USER_SETUP_INCOMPLETE));
189         assertTrue(isStateUnmanagedOrFinalizedWithCurrentState(STATE_USER_PROFILE_FINALIZED));
190     }
191 
verifyUserProvisioningStateSet(int state, int userId)192     private void verifyUserProvisioningStateSet(int state, int userId) {
193         verify(mDevicePolicyManager).setUserProvisioningState(state, userId);
194     }
195 
markUserSetupCompleted(boolean completed)196     private void markUserSetupCompleted(boolean completed) {
197         when(mSettingsFacade.isUserSetupCompleted(mContext)).thenReturn(completed);
198     }
199 
isStateUnmanagedOrFinalizedWithCurrentState(int currentState)200     private boolean isStateUnmanagedOrFinalizedWithCurrentState(int currentState) {
201         when(mDevicePolicyManager.getUserProvisioningState()).thenReturn(currentState);
202         return mHelper.isStateUnmanagedOrFinalized();
203     }
204 
createProvisioningParams(String action)205     private ProvisioningParams createProvisioningParams(String action) {
206         return new ProvisioningParams.Builder()
207                 .setDeviceAdminPackageName(TEST_MDM_PACKAGE_NAME)
208                 .setProvisioningAction(action)
209                 .build();
210     }
211 
setHeadlessSystemUserMode()212     private void setHeadlessSystemUserMode() {
213         when(mUtils.isHeadlessSystemUserMode()).thenReturn(true);
214     }
215 }
216