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