1 /* 2 * Copyright (C) 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 package com.android.managedprovisioning.preprovisioning; 17 18 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE; 19 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE; 20 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_PROFILE; 21 import static android.app.admin.DevicePolicyManager.CODE_MANAGED_USERS_NOT_SUPPORTED; 22 import static android.app.admin.DevicePolicyManager.CODE_OK; 23 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE; 24 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_ALLOWED_PROVISIONING_MODES; 25 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_DISCLAIMERS; 26 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_DISCLAIMER_CONTENT; 27 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_DISCLAIMER_HEADER; 28 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_IMEI; 29 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_KEEP_ACCOUNT_ON_MIGRATION; 30 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_LEAVE_ALL_SYSTEM_APPS_ENABLED; 31 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_LOCALE; 32 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_LOCAL_TIME; 33 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_MODE; 34 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT; 35 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_SERIAL_NUMBER; 36 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_SKIP_ENCRYPTION; 37 import static android.app.admin.DevicePolicyManager.EXTRA_PROVISIONING_TIME_ZONE; 38 import static android.app.admin.DevicePolicyManager.FLAG_SUPPORTED_MODES_DEVICE_OWNER; 39 import static android.app.admin.DevicePolicyManager.FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED; 40 import static android.app.admin.DevicePolicyManager.FLAG_SUPPORTED_MODES_PERSONALLY_OWNED; 41 import static android.app.admin.DevicePolicyManager.PROVISIONING_MODE_FULLY_MANAGED_DEVICE; 42 import static android.app.admin.DevicePolicyManager.PROVISIONING_MODE_MANAGED_PROFILE; 43 import static android.app.admin.DevicePolicyManager.PROVISIONING_MODE_MANAGED_PROFILE_ON_PERSONAL_DEVICE; 44 import static android.nfc.NfcAdapter.ACTION_NDEF_DISCOVERED; 45 46 import static com.android.managedprovisioning.common.Globals.ACTION_RESUME_PROVISIONING; 47 import static com.android.managedprovisioning.model.ProvisioningParams.DEFAULT_LOCAL_TIME; 48 49 import static com.google.common.truth.Truth.assertThat; 50 51 import static org.mockito.ArgumentMatchers.anyBoolean; 52 import static org.mockito.Mockito.any; 53 import static org.mockito.Mockito.anyInt; 54 import static org.mockito.Mockito.anyString; 55 import static org.mockito.Mockito.eq; 56 import static org.mockito.Mockito.never; 57 import static org.mockito.Mockito.verify; 58 import static org.mockito.Mockito.verifyNoMoreInteractions; 59 import static org.mockito.Mockito.when; 60 import static org.testng.Assert.assertThrows; 61 62 import android.app.ActivityManager; 63 import android.app.KeyguardManager; 64 import android.app.admin.DevicePolicyManager; 65 import android.content.ComponentName; 66 import android.content.Context; 67 import android.content.Intent; 68 import android.content.pm.ApplicationInfo; 69 import android.content.pm.PackageInfo; 70 import android.content.pm.PackageManager; 71 import android.content.pm.ResolveInfo; 72 import android.content.res.Resources; 73 import android.graphics.drawable.VectorDrawable; 74 import android.net.ConnectivityManager; 75 import android.net.Uri; 76 import android.os.Bundle; 77 import android.os.Handler; 78 import android.os.Looper; 79 import android.os.Parcelable; 80 import android.os.PersistableBundle; 81 import android.os.UserHandle; 82 import android.os.UserManager; 83 import android.service.persistentdata.PersistentDataBlockManager; 84 import android.telephony.TelephonyManager; 85 import android.test.AndroidTestCase; 86 import android.text.TextUtils; 87 88 import androidx.test.filters.SmallTest; 89 import androidx.test.platform.app.InstrumentationRegistry; 90 91 import com.android.managedprovisioning.R; 92 import com.android.managedprovisioning.analytics.TimeLogger; 93 import com.android.managedprovisioning.common.GetProvisioningModeUtils; 94 import com.android.managedprovisioning.common.IllegalProvisioningArgumentException; 95 import com.android.managedprovisioning.common.ManagedProvisioningSharedPreferences; 96 import com.android.managedprovisioning.common.PolicyComplianceUtils; 97 import com.android.managedprovisioning.common.SettingsFacade; 98 import com.android.managedprovisioning.common.Utils; 99 import com.android.managedprovisioning.model.DisclaimersParam; 100 import com.android.managedprovisioning.model.PackageDownloadInfo; 101 import com.android.managedprovisioning.model.ProvisioningParams; 102 import com.android.managedprovisioning.model.WifiInfo; 103 import com.android.managedprovisioning.parser.MessageParser; 104 105 import org.mockito.Mock; 106 import org.mockito.MockitoAnnotations; 107 108 import java.util.ArrayList; 109 import java.util.List; 110 import java.util.Locale; 111 112 @SmallTest 113 public class PreProvisioningActivityControllerTest extends AndroidTestCase { 114 private static final String TEST_MDM_PACKAGE = "com.test.mdm"; 115 private static final String TEST_MDM_PACKAGE_LABEL = "Test MDM"; 116 private static final ComponentName TEST_MDM_COMPONENT_NAME = new ComponentName(TEST_MDM_PACKAGE, 117 "com.test.mdm.DeviceAdmin"); 118 private static final String TEST_BOGUS_PACKAGE = "com.test.bogus"; 119 private static final String TEST_WIFI_SSID = "TestNet"; 120 private static final String MP_PACKAGE_NAME = "com.android.managedprovisioning"; 121 private static final int TEST_USER_ID = 10; 122 private static final PackageDownloadInfo PACKAGE_DOWNLOAD_INFO = 123 PackageDownloadInfo.Builder.builder() 124 .setCookieHeader("COOKIE_HEADER") 125 .setLocation("LOCATION") 126 .setMinVersion(1) 127 .setPackageChecksum(new byte[] {1}) 128 .setSignatureChecksum(new byte[] {1}) 129 .build(); 130 private static final String TEST_IMEI = "my imei"; 131 private static final String DISCLAIMER_HEADER = "header1"; 132 private static final Uri DISCLAIMER_CONTENT_URI = 133 Uri.parse("file:///test.example.uri/disclaimers.txt"); 134 private static final DisclaimersParam.Disclaimer[] OTHER_DISCLAIMERS = 135 {new DisclaimersParam.Disclaimer("header2", "content2")}; 136 private static final DisclaimersParam.Disclaimer[] DISCLAIMERS = 137 {new DisclaimersParam.Disclaimer(DISCLAIMER_HEADER, DISCLAIMER_CONTENT_URI.toString())}; 138 private static final DisclaimersParam DISCLAIMERS_PARAM = 139 new DisclaimersParam.Builder().setDisclaimers(DISCLAIMERS).build(); 140 private static final DisclaimersParam OTHER_DISCLAIMERS_PARAM = 141 new DisclaimersParam.Builder().setDisclaimers(OTHER_DISCLAIMERS).build(); 142 private static final Parcelable[] DISCLAIMERS_EXTRA = createDisclaimersExtra(); 143 private static final String LOCALE_EXTRA = "en_US"; 144 private static final Locale LOCALE = Locale.US; 145 private static final Locale OTHER_LOCALE = Locale.CANADA; 146 private static final String INVALID_LOCALE_EXTRA = "INVALIDLOCALE"; 147 private static final long LOCAL_TIME_EXTRA = 1234L; 148 private static final long OTHER_LOCAL_TIME = 4321L; 149 private static final String TIME_ZONE_EXTRA = "GMT"; 150 private static final String OTHER_TIME_ZONE = "GMT+1"; 151 152 @Mock 153 private Context mContext; 154 @Mock 155 Resources mResources; 156 @Mock 157 private DevicePolicyManager mDevicePolicyManager; 158 @Mock 159 private UserManager mUserManager; 160 @Mock 161 private PackageManager mPackageManager; 162 @Mock 163 private ActivityManager mActivityManager; 164 @Mock 165 private KeyguardManager mKeyguardManager; 166 @Mock 167 private PersistentDataBlockManager mPdbManager; 168 @Mock 169 private PreProvisioningActivityController.Ui mUi; 170 @Mock 171 private MessageParser mMessageParser; 172 @Mock 173 private Utils mUtils; 174 @Mock 175 private SettingsFacade mSettingsFacade; 176 @Mock 177 private Intent mIntent; 178 @Mock 179 private EncryptionController mEncryptionController; 180 @Mock 181 private TimeLogger mTimeLogger; 182 @Mock 183 private ManagedProvisioningSharedPreferences mSharedPreferences; 184 @Mock 185 private TelephonyManager mTelephonyManager; 186 187 private ProvisioningParams mParams; 188 private PreProvisioningViewModel mViewModel; 189 190 private PreProvisioningActivityController mController; 191 public static final PersistableBundle TEST_ADMIN_BUNDLE = new PersistableBundle(); 192 static { 193 TEST_ADMIN_BUNDLE.putInt("someKey", 123); 194 } 195 196 private Handler mHandler = new Handler(Looper.getMainLooper()); 197 198 @Override setUp()199 public void setUp() throws PackageManager.NameNotFoundException { 200 // this is necessary for mockito to work 201 System.setProperty("dexmaker.dexcache", getContext().getCacheDir().toString()); 202 203 MockitoAnnotations.initMocks(this); 204 205 when(mContext.getSystemServiceName(DevicePolicyManager.class)) 206 .thenReturn(Context.DEVICE_POLICY_SERVICE); 207 when(mContext.getSystemService(DevicePolicyManager.class)) 208 .thenReturn(mDevicePolicyManager); 209 210 when(mContext.getSystemServiceName(UserManager.class)) 211 .thenReturn(Context.USER_SERVICE); 212 when(mContext.getSystemService(UserManager.class)) 213 .thenReturn(mUserManager); 214 215 when(mContext.getPackageManager()).thenReturn(mPackageManager); 216 when(mContext.getSystemService(Context.ACTIVITY_SERVICE)).thenReturn(mActivityManager); 217 when(mContext.getSystemService(Context.KEYGUARD_SERVICE)).thenReturn(mKeyguardManager); 218 when(mContext.getSystemService(Context.PERSISTENT_DATA_BLOCK_SERVICE)) 219 .thenReturn(mPdbManager); 220 when(mContext.getPackageName()).thenReturn(MP_PACKAGE_NAME); 221 when(mContext.getResources()).thenReturn( 222 androidx.test.InstrumentationRegistry.getTargetContext().getResources()); 223 when(mContext.getSystemServiceName(TelephonyManager.class)) 224 .thenReturn(Context.TELEPHONY_SERVICE); 225 when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); 226 when(mTelephonyManager.getImei()).thenReturn(TEST_IMEI); 227 228 when(mUserManager.getUserHandle()).thenReturn(TEST_USER_ID); 229 230 when(mUtils.isEncryptionRequired()).thenReturn(false); 231 when(mUtils.currentLauncherSupportsManagedProfiles(mContext)).thenReturn(true); 232 when(mUserManager.canAddMoreManagedProfiles(anyInt(), anyBoolean())).thenReturn( 233 true); 234 235 when(mPackageManager.getApplicationIcon(anyString())).thenReturn(new VectorDrawable()); 236 when(mPackageManager.getApplicationLabel(any())).thenReturn(TEST_MDM_PACKAGE_LABEL); 237 when(mPackageManager.resolveActivity(any(), anyInt())).thenReturn(new ResolveInfo()); 238 239 when(mKeyguardManager.inKeyguardRestrictedInputMode()).thenReturn(false); 240 when(mDevicePolicyManager.getStorageEncryptionStatus()) 241 .thenReturn(DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE); 242 when(mSettingsFacade.isDuringSetupWizard(mContext)).thenReturn(false); 243 244 mViewModel = new PreProvisioningViewModel( 245 mTimeLogger, 246 mMessageParser, 247 mEncryptionController); 248 249 mController = new PreProvisioningActivityController( 250 mContext, 251 mUi, 252 mUtils, 253 mSettingsFacade, 254 mSharedPreferences, 255 new PolicyComplianceUtils(), 256 new GetProvisioningModeUtils(), 257 mViewModel, 258 (context, provisioningId) -> parcelables -> DISCLAIMERS_PARAM); 259 } 260 testManagedProfile()261 public void testManagedProfile() throws Exception { 262 // GIVEN an intent to provision a managed profile 263 prepareMocksForManagedProfileIntent(false); 264 // WHEN initiating provisioning 265 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 266 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE)); 267 // THEN the UI elements should be updated accordingly 268 verifyInitiateProfileOwnerUi(); 269 // WHEN the user consents 270 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 271 mController.continueProvisioningAfterUserConsent()); 272 // THEN start profile provisioning 273 verify(mUi).startProvisioning(mParams); 274 verify(mEncryptionController).cancelEncryptionReminder(); 275 verifyNoMoreInteractions(mUi); 276 } 277 testManagedProfile_provisioningNotAllowed()278 public void testManagedProfile_provisioningNotAllowed() throws Exception { 279 // GIVEN an intent to provision a managed profile, but provisioning mode is not allowed 280 prepareMocksForManagedProfileIntent(false); 281 when(mDevicePolicyManager.checkProvisioningPreCondition( 282 ACTION_PROVISION_MANAGED_PROFILE, TEST_MDM_PACKAGE)) 283 .thenReturn(CODE_MANAGED_USERS_NOT_SUPPORTED); 284 // WHEN initiating provisioning 285 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE); 286 // THEN show an error dialog 287 verify(mUi).showErrorAndClose(eq(R.string.cant_add_work_profile), 288 eq(R.string.work_profile_cant_be_added_contact_admin), any()); 289 verifyNoMoreInteractions(mUi); 290 } 291 testManagedProfile_nullCallingPackage()292 public void testManagedProfile_nullCallingPackage() throws Exception { 293 // GIVEN a device that is not currently encrypted 294 prepareMocksForManagedProfileIntent(false); 295 // WHEN initiating provisioning 296 mController.initiateProvisioning(mIntent, null); 297 // THEN error is shown 298 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 299 eq(R.string.contact_your_admin_for_help), any(String.class)); 300 verifyNoMoreInteractions(mUi); 301 } 302 testManagedProfile_invalidCallingPackage()303 public void testManagedProfile_invalidCallingPackage() throws Exception { 304 // GIVEN a device that is not currently encrypted 305 prepareMocksForManagedProfileIntent(false); 306 // WHEN initiating provisioning 307 mController.initiateProvisioning(mIntent, "com.android.invalid.dpc"); 308 // THEN error is shown 309 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 310 eq(R.string.contact_your_admin_for_help), any(String.class)); 311 verifyNoMoreInteractions(mUi); 312 } 313 testManagedProfile_withEncryption()314 public void testManagedProfile_withEncryption() throws Exception { 315 // GIVEN a device that is not currently encrypted 316 prepareMocksForManagedProfileIntent(false); 317 when(mUtils.isEncryptionRequired()).thenReturn(true); 318 // WHEN initiating managed profile provisioning 319 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 320 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE)); 321 // WHEN the user consents 322 mController.continueProvisioningAfterUserConsent(); 323 // THEN the UI elements should be updated accordingly 324 verifyInitiateProfileOwnerUi(); 325 // THEN show encryption screen 326 verify(mUi).requestEncryption(mParams); 327 verifyNoMoreInteractions(mUi); 328 } 329 testManagedProfile_afterEncryption()330 public void testManagedProfile_afterEncryption() throws Exception { 331 // GIVEN managed profile provisioning continues after successful encryption. In this case 332 // we don't set the startedByTrustedSource flag. 333 prepareMocksForAfterEncryption(ACTION_PROVISION_MANAGED_PROFILE, false); 334 // WHEN initiating with a continuation intent 335 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 336 mController.initiateProvisioning(mIntent, MP_PACKAGE_NAME)); 337 // THEN the UI elements should be updated accordingly 338 verifyInitiateProfileOwnerUi(); 339 // WHEN the user consents 340 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 341 mController.continueProvisioningAfterUserConsent()); 342 // THEN start profile provisioning 343 verify(mUi).startProvisioning(mParams); 344 verify(mEncryptionController).cancelEncryptionReminder(); 345 verifyNoMoreInteractions(mUi); 346 } 347 testManagedProfile_badLauncher()348 public void testManagedProfile_badLauncher() throws Exception { 349 // GIVEN that the current launcher does not support managed profiles 350 prepareMocksForManagedProfileIntent(false); 351 when(mUtils.currentLauncherSupportsManagedProfiles(mContext)).thenReturn(false); 352 // WHEN initiating managed profile provisioning 353 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 354 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE)); 355 // THEN the UI elements should be updated accordingly 356 verifyInitiateProfileOwnerUi(); 357 // WHEN the user consents 358 mController.continueProvisioningAfterUserConsent(); 359 // THEN show a dialog indicating that the current launcher is invalid 360 verify(mUi).showCurrentLauncherInvalid(); 361 verifyNoMoreInteractions(mUi); 362 } 363 testManagedProfile_wrongPackage()364 public void testManagedProfile_wrongPackage() throws Exception { 365 // GIVEN that the provisioning intent tries to set a package different from the caller 366 // as owner of the profile 367 prepareMocksForManagedProfileIntent(false); 368 // WHEN initiating managed profile provisioning 369 mController.initiateProvisioning(mIntent, TEST_BOGUS_PACKAGE); 370 // THEN show an error dialog and do not continue 371 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 372 eq(R.string.contact_your_admin_for_help), any()); 373 verifyNoMoreInteractions(mUi); 374 } 375 testManagedProfile_frp()376 public void testManagedProfile_frp() throws Exception { 377 // GIVEN managed profile provisioning is invoked from SUW with FRP active 378 prepareMocksForManagedProfileIntent(false); 379 when(mSettingsFacade.isDeviceProvisioned(mContext)).thenReturn(false); 380 // setting the data block size to any number greater than 0 should invoke FRP. 381 when(mPdbManager.getDataBlockSize()).thenReturn(4); 382 // WHEN initiating managed profile provisioning 383 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE); 384 // THEN show an error dialog and do not continue 385 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 386 eq(R.string.device_has_reset_protection_contact_admin), any()); 387 verifyNoMoreInteractions(mUi); 388 } 389 testCheckFactoryResetProtection_skipFrp()390 public void testCheckFactoryResetProtection_skipFrp() throws Exception { 391 // GIVEN managed profile provisioning is invoked from SUW with FRP active 392 when(mSettingsFacade.isDeviceProvisioned(mContext)).thenReturn(false); 393 // setting the data block size to any number greater than 0 to simulate FRP. 394 when(mPdbManager.getDataBlockSize()).thenReturn(4); 395 // GIVEN there is a persistent data package. 396 when(mContext.getResources()).thenReturn(mResources); 397 when(mResources.getString(anyInt())).thenReturn("test.persistent.data"); 398 // GIVEN the persistent data package is a system app. 399 PackageInfo packageInfo = new PackageInfo(); 400 ApplicationInfo applicationInfo = new ApplicationInfo(); 401 applicationInfo.flags = ApplicationInfo.FLAG_SYSTEM; 402 packageInfo.applicationInfo = applicationInfo; 403 when(mPackageManager.getPackageInfo(eq("test.persistent.data"), anyInt())) 404 .thenReturn(packageInfo); 405 406 // WHEN factory reset protection is checked for trusted source device provisioning. 407 ProvisioningParams provisioningParams = createParams(true, false, null, 408 ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE, TEST_MDM_PACKAGE); 409 boolean result = mController.checkFactoryResetProtection( 410 provisioningParams, "test.persistent.data"); 411 412 // THEN the check is successful despite the FRP data presence. 413 assertThat(result).isTrue(); 414 } 415 testManagedProfile_skipEncryption()416 public void testManagedProfile_skipEncryption() throws Exception { 417 // GIVEN an intent to provision a managed profile with skip encryption 418 prepareMocksForManagedProfileIntent(true); 419 when(mUtils.isEncryptionRequired()).thenReturn(true); 420 // WHEN initiating provisioning 421 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 422 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE)); 423 // THEN the UI elements should be updated accordingly 424 verifyInitiateProfileOwnerUi(); 425 // WHEN the user consents 426 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 427 mController.continueProvisioningAfterUserConsent()); 428 // THEN start profile provisioning 429 verify(mUi).startProvisioning(mParams); 430 verify(mUi, never()).requestEncryption(any(ProvisioningParams.class)); 431 verify(mEncryptionController).cancelEncryptionReminder(); 432 verifyNoMoreInteractions(mUi); 433 } 434 testManagedProfile_encryptionNotSupported()435 public void testManagedProfile_encryptionNotSupported() throws Exception { 436 // GIVEN an intent to provision a managed profile on an unencrypted device that does not 437 // support encryption 438 prepareMocksForManagedProfileIntent(false); 439 when(mUtils.isEncryptionRequired()).thenReturn(true); 440 when(mDevicePolicyManager.getStorageEncryptionStatus()) 441 .thenReturn(DevicePolicyManager.ENCRYPTION_STATUS_UNSUPPORTED); 442 // WHEN initiating provisioning 443 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 444 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE)); 445 // WHEN the user consents 446 mController.continueProvisioningAfterUserConsent(); 447 // THEN the UI elements should be updated accordingly 448 verifyInitiateProfileOwnerUi(); 449 // THEN show an error indicating that this device does not support encryption 450 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 451 eq(R.string.device_doesnt_allow_encryption_contact_admin), any()); 452 verifyNoMoreInteractions(mUi); 453 } 454 testInitiateProvisioning_withNfc_showsOwnershipDisclaimer()455 public void testInitiateProvisioning_withNfc_showsOwnershipDisclaimer() throws Exception { 456 // GIVEN provisioning was started via an NFC tap and should show ownership disclaimer 457 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 458 when(mUtils.shouldShowOwnershipDisclaimerScreen(eq(mParams))).thenReturn(true); 459 460 // WHEN initiating NFC provisioning 461 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 462 mController.initiateProvisioning(mIntent, /* callingPackage= */ null)); 463 464 // THEN show the ownership disclaimer 465 verify(mUi).showOwnershipDisclaimerScreen(eq(mParams)); 466 verifyNoMoreInteractions(mUi); 467 } 468 testInitiateProvisioning_withNfc_skipsOwnershipDisclaimer()469 public void testInitiateProvisioning_withNfc_skipsOwnershipDisclaimer() throws Exception { 470 // GIVEN provisioning was started via an NFC tap and should show ownership disclaimer 471 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 472 when(mUtils.shouldShowOwnershipDisclaimerScreen(eq(mParams))).thenReturn(false); 473 474 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> { 475 // WHEN initiating NFC provisioning 476 mController.initiateProvisioning(mIntent, /* callingPackage= */ null); 477 }); 478 479 // THEN show the ownership disclaimer 480 verify(mUi).initiateUi(any()); 481 verifyNoMoreInteractions(mUi); 482 } 483 484 // TODO(b/177575786): Migrate outdated PreProvisioningControllerTest tests to robolectric 485 /* 486 public void testNfc() throws Exception { 487 // GIVEN provisioning was started via an NFC tap and device is already encrypted 488 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 489 // WHEN initiating NFC provisioning 490 mController.initiateProvisioning(mIntent, null, null); 491 // WHEN the user consents 492 mController.continueProvisioningAfterUserConsent(); 493 // THEN start device owner provisioning 494 verifyInitiateDeviceOwnerUi(); 495 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 496 verify(mEncryptionController).cancelEncryptionReminder(); 497 verifyNoMoreInteractions(mUi); 498 } 499 500 public void testNfc_skipEncryption() throws Exception { 501 // GIVEN provisioning was started via an NFC tap with encryption skipped 502 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, true); 503 when(mUtils.isEncryptionRequired()).thenReturn(true); 504 // WHEN initiating NFC provisioning 505 506 mController.initiateProvisioning(mIntent, null, null); 507 // WHEN the user consents 508 mController.continueProvisioningAfterUserConsent(); 509 // THEN start device owner provisioning 510 verifyInitiateDeviceOwnerUi(); 511 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 512 verify(mUi, never()).requestEncryption(any(ProvisioningParams.class)); 513 verify(mEncryptionController).cancelEncryptionReminder(); 514 verifyNoMoreInteractions(mUi); 515 } 516 517 public void testNfc_withEncryption() throws Exception { 518 // GIVEN provisioning was started via an NFC tap with encryption necessary 519 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 520 when(mUtils.isEncryptionRequired()).thenReturn(true); 521 // WHEN initiating NFC provisioning 522 mController.initiateProvisioning(mIntent, null, null); 523 // WHEN the user consents 524 mController.continueProvisioningAfterUserConsent(); 525 // THEN show encryption screen 526 verifyInitiateDeviceOwnerUi(); 527 verify(mUi).requestEncryption(mParams); 528 verifyNoMoreInteractions(mUi); 529 } 530 531 public void testNfc_afterEncryption() throws Exception { 532 // GIVEN provisioning was started via an NFC tap and we have gone through encryption 533 // in this case the device gets resumed with the DO intent and startedByTrustedSource flag 534 // set 535 prepareMocksForAfterEncryption(ACTION_PROVISION_MANAGED_DEVICE, true); 536 // WHEN continuing NFC provisioning after encryption 537 mController.initiateProvisioning(mIntent, null, null); 538 // WHEN the user consents 539 mController.continueProvisioningAfterUserConsent(); 540 // THEN start device owner provisioning 541 verifyInitiateDeviceOwnerUi(); 542 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 543 verifyNoMoreInteractions(mUi); 544 } 545 546 public void testNfc_frp() throws Exception { 547 // GIVEN provisioning was started via an NFC tap, but the device is locked with FRP 548 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 549 // setting the data block size to any number greater than 0 should invoke FRP. 550 when(mPdbManager.getDataBlockSize()).thenReturn(4); 551 // WHEN initiating NFC provisioning 552 mController.initiateProvisioning(mIntent, null, null); 553 // THEN show an error dialog 554 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 555 eq(R.string.device_has_reset_protection_contact_admin), any()); 556 verifyNoMoreInteractions(mUi); 557 } 558 559 public void testNfc_encryptionNotSupported() throws Exception { 560 // GIVEN provisioning was started via an NFC tap, the device is not encrypted and encryption 561 // is not supported on the device 562 prepareMocksForNfcIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 563 when(mUtils.isEncryptionRequired()).thenReturn(true); 564 when(mDevicePolicyManager.getStorageEncryptionStatus()) 565 .thenReturn(DevicePolicyManager.ENCRYPTION_STATUS_UNSUPPORTED); 566 // WHEN initiating NFC provisioning 567 mController.initiateProvisioning(mIntent, null, null); 568 // WHEN the user consents 569 mController.continueProvisioningAfterUserConsent(); 570 // THEN show an error dialog 571 verifyInitiateDeviceOwnerUi(); 572 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 573 eq(R.string.device_doesnt_allow_encryption_contact_admin), any()); 574 verifyNoMoreInteractions(mUi); 575 } 576 577 public void testQr() throws Exception { 578 // GIVEN provisioning was started via a QR code and device is already encrypted 579 prepareMocksForQrIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 580 // WHEN initiating QR provisioning 581 mController.initiateProvisioning(mIntent, null, null); 582 // WHEN the user consents 583 mController.continueProvisioningAfterUserConsent(); 584 // THEN start device owner provisioning 585 verifyInitiateDeviceOwnerUi(); 586 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 587 verifyNoMoreInteractions(mUi); 588 } 589 590 public void testQr_skipEncryption() throws Exception { 591 // GIVEN provisioning was started via a QR code with encryption skipped 592 prepareMocksForQrIntent(ACTION_PROVISION_MANAGED_DEVICE, true); 593 when(mUtils.isEncryptionRequired()).thenReturn(true); 594 // WHEN initiating QR provisioning 595 mController.initiateProvisioning(mIntent, null, null); 596 // WHEN the user consents 597 mController.continueProvisioningAfterUserConsent(); 598 // THEN start device owner provisioning 599 verifyInitiateDeviceOwnerUi(); 600 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 601 verify(mUi, never()).requestEncryption(any()); 602 verifyNoMoreInteractions(mUi); 603 } 604 605 public void testQr_withEncryption() throws Exception { 606 // GIVEN provisioning was started via a QR code with encryption necessary 607 prepareMocksForQrIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 608 when(mUtils.isEncryptionRequired()).thenReturn(true); 609 // WHEN initiating QR provisioning 610 mController.initiateProvisioning(mIntent, null, null); 611 // WHEN the user consents 612 mController.continueProvisioningAfterUserConsent(); 613 // THEN show encryption screen 614 verifyInitiateDeviceOwnerUi(); 615 verify(mUi).requestEncryption(mParams); 616 verifyNoMoreInteractions(mUi); 617 } 618 619 public void testQr_frp() throws Exception { 620 // GIVEN provisioning was started via a QR code, but the device is locked with FRP 621 prepareMocksForQrIntent(ACTION_PROVISION_MANAGED_DEVICE, false); 622 // setting the data block size to any number greater than 0 should invoke FRP. 623 when(mPdbManager.getDataBlockSize()).thenReturn(4); 624 // WHEN initiating QR provisioning 625 mController.initiateProvisioning(mIntent, null, null); 626 // THEN show an error dialog 627 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 628 eq(R.string.device_has_reset_protection_contact_admin), any()); 629 verifyNoMoreInteractions(mUi); 630 } 631 632 public void testDeviceOwner() throws Exception { 633 // GIVEN device owner provisioning was started and device is already encrypted 634 prepareMocksForDoIntent(true); 635 // WHEN initiating provisioning 636 mController.initiateProvisioning(mIntent, null, TEST_MDM_PACKAGE); 637 // THEN the UI elements should be updated accordingly 638 verifyInitiateDeviceOwnerUi(); 639 // WHEN the user consents 640 mController.continueProvisioningAfterUserConsent(); 641 // THEN start device owner provisioning 642 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 643 verify(mEncryptionController).cancelEncryptionReminder(); 644 verifyNoMoreInteractions(mUi); 645 } 646 647 public void testDeviceOwner_skipEncryption() throws Exception { 648 // GIVEN device owner provisioning was started with skip encryption flag 649 prepareMocksForDoIntent(true); 650 when(mUtils.isEncryptionRequired()).thenReturn(true); 651 // WHEN initiating provisioning 652 mController.initiateProvisioning(mIntent, null, TEST_MDM_PACKAGE); 653 // THEN the UI elements should be updated accordingly 654 verifyInitiateDeviceOwnerUi(); 655 // WHEN the user consents 656 mController.continueProvisioningAfterUserConsent(); 657 // THEN start device owner provisioning 658 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 659 verify(mUi, never()).requestEncryption(any()); 660 verify(mEncryptionController).cancelEncryptionReminder(); 661 verifyNoMoreInteractions(mUi); 662 } 663 664 // TODO: There is a difference in behaviour here between the managed profile and the device 665 // owner case: In managed profile case, we invoke encryption after user clicks next, but in 666 // device owner mode we invoke it straight away. Also in theory no need to update 667 // the UI elements if we're moving away from this activity straight away. 668 public void testDeviceOwner_withEncryption() throws Exception { 669 // GIVEN device owner provisioning is started with encryption needed 670 prepareMocksForDoIntent(false); 671 when(mUtils.isEncryptionRequired()).thenReturn(true); 672 // WHEN initiating provisioning 673 mController.initiateProvisioning(mIntent, null, TEST_MDM_PACKAGE); 674 // WHEN the user consents 675 mController.continueProvisioningAfterUserConsent(); 676 // THEN update the UI elements and show encryption screen 677 verifyInitiateDeviceOwnerUi(); 678 verify(mUi).requestEncryption(mParams); 679 verifyNoMoreInteractions(mUi); 680 } 681 682 public void testDeviceOwner_afterEncryption() throws Exception { 683 // GIVEN device owner provisioning is continued after encryption. In this case we do not set 684 // the startedByTrustedSource flag. 685 prepareMocksForAfterEncryption(ACTION_PROVISION_MANAGED_DEVICE, false); 686 // WHEN provisioning is continued 687 mController.initiateProvisioning(mIntent, null, null); 688 // THEN the UI elements should be updated accordingly 689 verifyInitiateDeviceOwnerUi(); 690 // WHEN the user consents 691 mController.continueProvisioningAfterUserConsent(); 692 // THEN start device owner provisioning 693 verify(mUi).startProvisioning(mUserManager.getUserHandle(), mParams); 694 verify(mEncryptionController).cancelEncryptionReminder(); 695 verifyNoMoreInteractions(mUi); 696 } 697 698 public void testDeviceOwner_frp() throws Exception { 699 // GIVEN device owner provisioning is invoked with FRP active 700 prepareMocksForDoIntent(false); 701 // setting the data block size to any number greater than 0 should invoke FRP. 702 when(mPdbManager.getDataBlockSize()).thenReturn(4); 703 // WHEN initiating provisioning 704 mController.initiateProvisioning(mIntent, null, TEST_MDM_PACKAGE); 705 // THEN show an error dialog 706 verify(mUi).showErrorAndClose(eq(R.string.cant_set_up_device), 707 eq(R.string.device_has_reset_protection_contact_admin), any()); 708 verifyNoMoreInteractions(mUi); 709 }*/ 710 testParamsNotLoaded_throwsException()711 public void testParamsNotLoaded_throwsException() { 712 assertThrows(IllegalStateException.class, () -> mController.getParams()); 713 } 714 testInitiateProvisioning_showsWifiPicker()715 public void testInitiateProvisioning_showsWifiPicker() { 716 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 717 .build(); 718 initiateProvisioning(params); 719 verify(mUi).requestWifiPick(); 720 } 721 testInitiateProvisioning_useMobileData_showsWifiPicker()722 public void testInitiateProvisioning_useMobileData_showsWifiPicker() { 723 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 724 .setUseMobileData(true) 725 .build(); 726 initiateProvisioning(params); 727 verify(mUi).requestWifiPick(); 728 } 729 testInitiateProvisioning_useMobileData_noWifiPicker()730 public void testInitiateProvisioning_useMobileData_noWifiPicker() { 731 when(mUtils.isMobileNetworkConnectedToInternet(mContext)).thenReturn(true); 732 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 733 .setUseMobileData(true) 734 .build(); 735 initiateProvisioning(params); 736 verify(mUi, never()).requestWifiPick(); 737 } 738 testInitiateProvisioning_connectedToWifiOrEthernet_noWifiPicker()739 public void testInitiateProvisioning_connectedToWifiOrEthernet_noWifiPicker() { 740 when(mUtils.isNetworkTypeConnected(mContext, ConnectivityManager.TYPE_WIFI, 741 ConnectivityManager.TYPE_ETHERNET)).thenReturn(true); 742 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 743 .build(); 744 initiateProvisioning(params); 745 verify(mUi, never()).requestWifiPick(); 746 } 747 testInitiateProvisioning_noAdminDownloadInfo_noWifiPicker()748 public void testInitiateProvisioning_noAdminDownloadInfo_noWifiPicker() { 749 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 750 .setDeviceAdminDownloadInfo(null) 751 .build(); 752 initiateProvisioning(params); 753 verify(mUi, never()).requestWifiPick(); 754 } 755 testInitiateProvisioning_wifiInfo_noWifiPicker()756 public void testInitiateProvisioning_wifiInfo_noWifiPicker() { 757 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 758 .setWifiInfo(new WifiInfo.Builder().setSsid(TEST_WIFI_SSID).build()) 759 .build(); 760 initiateProvisioning(params); 761 verify(mUi, never()).requestWifiPick(); 762 } 763 764 public void testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_exactExtras()765 testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_exactExtras() { 766 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 767 .setIsOrganizationOwnedProvisioning(true) 768 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 769 .setAllowedProvisioningModes(new ArrayList<>(List.of( 770 PROVISIONING_MODE_MANAGED_PROFILE, 771 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 772 ))) 773 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED) 774 .build(); 775 initiateProvisioning(params); 776 777 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 778 779 assertThat(bundle.size()).isEqualTo(5); 780 } 781 testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_imeiPassed()782 public void testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_imeiPassed() { 783 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 784 .setIsOrganizationOwnedProvisioning(true) 785 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 786 .setAllowedProvisioningModes(new ArrayList<>(List.of( 787 PROVISIONING_MODE_MANAGED_PROFILE, 788 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 789 ))) 790 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED) 791 .build(); 792 initiateProvisioning(params); 793 794 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 795 796 assertThat(bundle.getString(EXTRA_PROVISIONING_IMEI)).isEqualTo(TEST_IMEI); 797 } 798 testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_serialNumberPassed()799 public void testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_serialNumberPassed() { 800 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 801 .setIsOrganizationOwnedProvisioning(true) 802 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 803 .setAllowedProvisioningModes(new ArrayList<>(List.of( 804 PROVISIONING_MODE_MANAGED_PROFILE, 805 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 806 ))) 807 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED) 808 .build(); 809 initiateProvisioning(params); 810 811 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 812 813 assertThat(bundle.containsKey(EXTRA_PROVISIONING_SERIAL_NUMBER)).isTrue(); 814 } 815 816 public void testGetAdditionalExtrasForGetProvisioningModeIntent_nonOrgDevice_adminBundlePassed()817 testGetAdditionalExtrasForGetProvisioningModeIntent_nonOrgDevice_adminBundlePassed() { 818 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 819 .setIsOrganizationOwnedProvisioning(false) 820 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 821 .setAllowedProvisioningModes( 822 new ArrayList<>(List.of(PROVISIONING_MODE_MANAGED_PROFILE))) 823 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 824 .build(); 825 initiateProvisioning(params); 826 827 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 828 829 assertThat(bundle.keySet()).contains(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE); 830 assertThat((PersistableBundle) bundle.getParcelable(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE)) 831 .isEqualTo(TEST_ADMIN_BUNDLE); 832 } 833 834 public void testGetAdditionalExtrasForGetProvisioningModeIntent_nonOrgDevice_allowedModesPassed()835 testGetAdditionalExtrasForGetProvisioningModeIntent_nonOrgDevice_allowedModesPassed() { 836 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 837 .setIsOrganizationOwnedProvisioning(false) 838 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 839 .setAllowedProvisioningModes( 840 new ArrayList<>(List.of(PROVISIONING_MODE_MANAGED_PROFILE))) 841 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 842 .build(); 843 initiateProvisioning(params); 844 845 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 846 847 assertThat(bundle.getIntegerArrayList(EXTRA_PROVISIONING_ALLOWED_PROVISIONING_MODES)) 848 .containsExactly(PROVISIONING_MODE_MANAGED_PROFILE); 849 } 850 851 public void testGetAdditionalExtrasForGetProvisioningModeIntent_nonOrgDevice_hasExactlyTwoExtras()852 testGetAdditionalExtrasForGetProvisioningModeIntent_nonOrgDevice_hasExactlyTwoExtras() { 853 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 854 .setIsOrganizationOwnedProvisioning(false) 855 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 856 .setAllowedProvisioningModes( 857 new ArrayList<>(List.of(PROVISIONING_MODE_MANAGED_PROFILE))) 858 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 859 .build(); 860 initiateProvisioning(params); 861 862 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 863 864 assertThat(bundle.size()).isEqualTo(2); 865 } 866 testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_adminBundlePassed()867 public void testGetAdditionalExtrasForGetProvisioningModeIntent_orgDevice_adminBundlePassed() { 868 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 869 .setIsOrganizationOwnedProvisioning(true) 870 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 871 .build(); 872 initiateProvisioning(params); 873 874 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 875 876 assertThat((PersistableBundle) bundle.getParcelable(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE)) 877 .isEqualTo(TEST_ADMIN_BUNDLE); 878 } 879 880 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_adminBundlePassed()881 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_adminBundlePassed() { 882 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 883 .setIsOrganizationOwnedProvisioning(true) 884 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 885 .setAllowedProvisioningModes( 886 new ArrayList<>(List.of(PROVISIONING_MODE_FULLY_MANAGED_DEVICE))) 887 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_DEVICE_OWNER) 888 .build(); 889 initiateProvisioning(params); 890 891 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 892 893 assertThat(bundle.keySet()).contains(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE); 894 assertThat((PersistableBundle) bundle.getParcelable(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE)) 895 .isEqualTo(TEST_ADMIN_BUNDLE); 896 } 897 898 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_exactExtras()899 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_exactExtras() { 900 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 901 .setIsOrganizationOwnedProvisioning(true) 902 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 903 .setAllowedProvisioningModes(new ArrayList<>(List.of( 904 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 905 ))) 906 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_DEVICE_OWNER) 907 .build(); 908 initiateProvisioning(params); 909 910 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 911 912 assertThat(bundle.size()).isEqualTo(5); 913 } 914 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_imeiPassed()915 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_imeiPassed() { 916 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 917 .setIsOrganizationOwnedProvisioning(true) 918 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 919 .setAllowedProvisioningModes(new ArrayList<>(List.of( 920 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 921 ))) 922 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_DEVICE_OWNER) 923 .build(); 924 initiateProvisioning(params); 925 926 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 927 928 assertThat(bundle.getString(EXTRA_PROVISIONING_IMEI)).isEqualTo(TEST_IMEI); 929 } 930 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_serialNumberPassed()931 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManagedDevice_serialNumberPassed() { 932 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 933 .setIsOrganizationOwnedProvisioning(true) 934 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 935 .setAllowedProvisioningModes(new ArrayList<>(List.of( 936 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 937 ))) 938 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_DEVICE_OWNER) 939 .build(); 940 initiateProvisioning(params); 941 942 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 943 944 assertThat(bundle.containsKey(EXTRA_PROVISIONING_SERIAL_NUMBER)).isTrue(); 945 } 946 947 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManaged_hasOptOutExtra()948 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManaged_hasOptOutExtra() { 949 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 950 .setIsOrganizationOwnedProvisioning(true) 951 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 952 .setAllowedProvisioningModes(new ArrayList<>(List.of( 953 PROVISIONING_MODE_MANAGED_PROFILE, 954 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 955 ))) 956 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED) 957 .build(); 958 initiateProvisioning(params); 959 960 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 961 962 assertThat(bundle.getBoolean(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 963 .isEqualTo(false); 964 } 965 966 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManaged_optOutExtraIsTrue()967 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManaged_optOutExtraIsTrue() { 968 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 969 .setIsOrganizationOwnedProvisioning(true) 970 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 971 .setAllowedProvisioningModes(new ArrayList<>(List.of( 972 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 973 ))) 974 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_DEVICE_OWNER) 975 .setDeviceOwnerPermissionGrantOptOut(true) 976 .build(); 977 initiateProvisioning(params); 978 979 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 980 981 assertThat(bundle.getBoolean(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 982 .isEqualTo(true); 983 } 984 985 public void testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfile_optOutExtraIsFalseByDefault()986 testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfile_optOutExtraIsFalseByDefault() { 987 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 988 .setIsOrganizationOwnedProvisioning(false) 989 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 990 .setAllowedProvisioningModes( 991 new ArrayList<>(List.of(PROVISIONING_MODE_MANAGED_PROFILE))) 992 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 993 .build(); 994 initiateProvisioning(params); 995 996 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 997 998 assertThat(bundle.containsKey(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 999 .isEqualTo(false); 1000 } 1001 1002 public void testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManaged_optOutExtraIsFalse()1003 testGetAdditionalExtrasForGetProvisioningModeIntent_fullyManaged_optOutExtraIsFalse() { 1004 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 1005 .setIsOrganizationOwnedProvisioning(true) 1006 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 1007 .setAllowedProvisioningModes(new ArrayList<>(List.of( 1008 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 1009 ))) 1010 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_DEVICE_OWNER) 1011 .setDeviceOwnerPermissionGrantOptOut(false) 1012 .build(); 1013 initiateProvisioning(params); 1014 1015 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 1016 1017 assertThat(bundle.getBoolean(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 1018 .isEqualTo(false); 1019 } 1020 1021 public void testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfileByo_optOutExtraNotPresent()1022 testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfileByo_optOutExtraNotPresent() { 1023 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 1024 .setIsOrganizationOwnedProvisioning(false) 1025 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 1026 .setAllowedProvisioningModes( 1027 new ArrayList<>( 1028 List.of(PROVISIONING_MODE_MANAGED_PROFILE_ON_PERSONAL_DEVICE))) 1029 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 1030 .build(); 1031 initiateProvisioning(params); 1032 1033 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 1034 1035 assertThat(bundle.containsKey(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 1036 .isEqualTo(false); 1037 } 1038 1039 public void testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfile_optOutExtraNotPresent()1040 testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfile_optOutExtraNotPresent() { 1041 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 1042 .setIsOrganizationOwnedProvisioning(false) 1043 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 1044 .setAllowedProvisioningModes( 1045 new ArrayList<>(List.of(PROVISIONING_MODE_MANAGED_PROFILE))) 1046 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 1047 .setDeviceOwnerPermissionGrantOptOut(true) 1048 .build(); 1049 initiateProvisioning(params); 1050 1051 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 1052 1053 assertThat(bundle.containsKey(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 1054 .isEqualTo(false); 1055 } 1056 1057 public void testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfileByo_optOutExtraHasNoEffect()1058 testGetAdditionalExtrasForGetProvisioningModeIntent_managedProfileByo_optOutExtraHasNoEffect() { 1059 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 1060 .setIsOrganizationOwnedProvisioning(false) 1061 .setAdminExtrasBundle(TEST_ADMIN_BUNDLE) 1062 .setAllowedProvisioningModes( 1063 new ArrayList<>( 1064 List.of(PROVISIONING_MODE_MANAGED_PROFILE_ON_PERSONAL_DEVICE))) 1065 .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_PERSONALLY_OWNED) 1066 .setDeviceOwnerPermissionGrantOptOut(true) 1067 .build(); 1068 initiateProvisioning(params); 1069 1070 Bundle bundle = mController.getAdditionalExtrasForGetProvisioningModeIntent(); 1071 1072 assertThat(bundle.containsKey(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT)) 1073 .isEqualTo(false); 1074 } 1075 testUpdateProvisioningParamsFromIntent_managedProfileModeWithAccountMigratedExtraTrue_setsParamToTrue()1076 public void testUpdateProvisioningParamsFromIntent_managedProfileModeWithAccountMigratedExtraTrue_setsParamToTrue() { 1077 Intent resultIntent = createResultIntentWithManagedProfile() 1078 .putExtra(EXTRA_PROVISIONING_KEEP_ACCOUNT_ON_MIGRATION, true); 1079 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1080 .build(); 1081 initiateProvisioning(params); 1082 1083 mController.updateProvisioningParamsFromIntent(resultIntent); 1084 1085 assertThat(mController.getParams().keepAccountMigrated).isTrue(); 1086 } 1087 testUpdateProvisioningParamsFromIntent_managedProfileModeWithAccountMigratedExtraFalse_setsParamToFalse()1088 public void testUpdateProvisioningParamsFromIntent_managedProfileModeWithAccountMigratedExtraFalse_setsParamToFalse() { 1089 Intent resultIntent = createResultIntentWithManagedProfile() 1090 .putExtra(EXTRA_PROVISIONING_KEEP_ACCOUNT_ON_MIGRATION, false); 1091 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1092 .build(); 1093 initiateProvisioning(params); 1094 1095 mController.updateProvisioningParamsFromIntent(resultIntent); 1096 1097 assertThat(mController.getParams().keepAccountMigrated).isFalse(); 1098 } 1099 testUpdateProvisioningParamsFromIntent_managedProfileMode_accountMigratedIsFalse()1100 public void testUpdateProvisioningParamsFromIntent_managedProfileMode_accountMigratedIsFalse() { 1101 Intent resultIntent = createResultIntentWithManagedProfile(); 1102 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1103 .build(); 1104 initiateProvisioning(params); 1105 1106 mController.updateProvisioningParamsFromIntent(resultIntent); 1107 1108 assertThat(mController.getParams().keepAccountMigrated).isFalse(); 1109 } 1110 testUpdateProvisioningParamsFromIntent_managedDeviceModeWithAccountMigratedExtraTrue_accountMigratedIsFalse()1111 public void testUpdateProvisioningParamsFromIntent_managedDeviceModeWithAccountMigratedExtraTrue_accountMigratedIsFalse() { 1112 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1113 .putExtra(EXTRA_PROVISIONING_KEEP_ACCOUNT_ON_MIGRATION, true); 1114 final ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1115 .build(); 1116 initiateProvisioning(params); 1117 1118 mController.updateProvisioningParamsFromIntent(resultIntent); 1119 1120 assertThat(mController.getParams().keepAccountMigrated).isFalse(); 1121 } 1122 testUpdateProvisioningParamsFromIntent_managedProfileModeWithLeaveSystemAppsEnabledTrue_setsParamToTrue()1123 public void testUpdateProvisioningParamsFromIntent_managedProfileModeWithLeaveSystemAppsEnabledTrue_setsParamToTrue() { 1124 Intent resultIntent = createResultIntentWithManagedProfile() 1125 .putExtra(EXTRA_PROVISIONING_LEAVE_ALL_SYSTEM_APPS_ENABLED, true); 1126 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1127 .build(); 1128 initiateProvisioning(params); 1129 1130 mController.updateProvisioningParamsFromIntent(resultIntent); 1131 1132 assertThat(mController.getParams().leaveAllSystemAppsEnabled).isTrue(); 1133 } 1134 testUpdateProvisioningParamsFromIntent_managedProfileModeWithLeaveSystemAppsEnabledFalse_setsParamToFalse()1135 public void testUpdateProvisioningParamsFromIntent_managedProfileModeWithLeaveSystemAppsEnabledFalse_setsParamToFalse() { 1136 Intent resultIntent = createResultIntentWithManagedProfile() 1137 .putExtra(EXTRA_PROVISIONING_LEAVE_ALL_SYSTEM_APPS_ENABLED, false); 1138 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1139 .build(); 1140 initiateProvisioning(params); 1141 1142 mController.updateProvisioningParamsFromIntent(resultIntent); 1143 1144 assertThat(mController.getParams().leaveAllSystemAppsEnabled).isFalse(); 1145 } 1146 testUpdateProvisioningParamsFromIntent_managedProfileMode_leaveSystemAppsEnabledIsFalse()1147 public void testUpdateProvisioningParamsFromIntent_managedProfileMode_leaveSystemAppsEnabledIsFalse() { 1148 Intent resultIntent = createResultIntentWithManagedProfile(); 1149 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1150 .build(); 1151 initiateProvisioning(params); 1152 1153 mController.updateProvisioningParamsFromIntent(resultIntent); 1154 1155 assertThat(mController.getParams().leaveAllSystemAppsEnabled).isFalse(); 1156 } 1157 testUpdateProvisioningParamsFromIntent_managedDeviceModeWithLeaveSystemAppsEnabledTrue_paramIsFalse()1158 public void testUpdateProvisioningParamsFromIntent_managedDeviceModeWithLeaveSystemAppsEnabledTrue_paramIsFalse() { 1159 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1160 .putExtra(EXTRA_PROVISIONING_LEAVE_ALL_SYSTEM_APPS_ENABLED, true); 1161 final ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1162 .build(); 1163 initiateProvisioning(params); 1164 1165 mController.updateProvisioningParamsFromIntent(resultIntent); 1166 1167 assertThat(mController.getParams().leaveAllSystemAppsEnabled).isFalse(); 1168 } 1169 testUpdateProvisioningParamsFromIntent_adminBundlePassed_setsParam()1170 public void testUpdateProvisioningParamsFromIntent_adminBundlePassed_setsParam() { 1171 PersistableBundle testAdminExtrasBundle = new PersistableBundle(); 1172 testAdminExtrasBundle.putInt("key1", 2); 1173 testAdminExtrasBundle.putString("key2", "value2"); 1174 Intent resultIntent = createResultIntentWithManagedProfile() 1175 .putExtra(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE, testAdminExtrasBundle); 1176 final ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1177 .build(); 1178 initiateProvisioning(params); 1179 1180 mController.updateProvisioningParamsFromIntent(resultIntent); 1181 1182 assertThat(mController.getParams().adminExtrasBundle).isEqualTo(testAdminExtrasBundle); 1183 } 1184 testUpdateProvisioningParamsFromIntent_adminBundlePassedWithPreexistingAdminBundle_appendsValues()1185 public void testUpdateProvisioningParamsFromIntent_adminBundlePassedWithPreexistingAdminBundle_appendsValues() { 1186 PersistableBundle resultingAdminBundle = new PersistableBundle(); 1187 resultingAdminBundle.putInt("key1", 2); 1188 resultingAdminBundle.putInt("someKey", 124); 1189 PersistableBundle existingAdminBundle = new PersistableBundle(); 1190 existingAdminBundle.putInt("key2", 3); 1191 existingAdminBundle.putInt("someKey", 123); 1192 PersistableBundle expectedResult = new PersistableBundle(); 1193 expectedResult.putInt("key1", 2); 1194 expectedResult.putInt("key2", 3); 1195 expectedResult.putInt("someKey", 124); 1196 Intent resultIntent = createResultIntentWithManagedProfile() 1197 .putExtra(EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE, resultingAdminBundle); 1198 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 1199 .setAdminExtrasBundle(existingAdminBundle) 1200 .setKeepAccountMigrated(false) 1201 .setAllowedProvisioningModes(new ArrayList<>(List.of( 1202 PROVISIONING_MODE_MANAGED_PROFILE 1203 ))) 1204 .build(); 1205 initiateProvisioning(params); 1206 1207 mController.updateProvisioningParamsFromIntent(resultIntent); 1208 1209 assertThat(mController.getParams().adminExtrasBundle.toString()) 1210 .isEqualTo(expectedResult.toString()); 1211 } 1212 testUpdateProvisioningParamsFromIntent_noAdminBundleResult_existingAdminBundleRetained()1213 public void testUpdateProvisioningParamsFromIntent_noAdminBundleResult_existingAdminBundleRetained() { 1214 PersistableBundle existingAdminBundle = new PersistableBundle(); 1215 existingAdminBundle.putInt("key2", 3); 1216 existingAdminBundle.putInt("someKey", 123); 1217 Intent resultIntent = createResultIntentWithManagedProfile(); 1218 final ProvisioningParams params = createProvisioningParamsBuilderForInitiateProvisioning() 1219 .setAdminExtrasBundle(existingAdminBundle) 1220 .setKeepAccountMigrated(false) 1221 .setAllowedProvisioningModes(new ArrayList<>(List.of( 1222 PROVISIONING_MODE_MANAGED_PROFILE 1223 ))) 1224 .build(); 1225 initiateProvisioning(params); 1226 1227 mController.updateProvisioningParamsFromIntent(resultIntent); 1228 1229 assertThat(mController.getParams().adminExtrasBundle.toString()) 1230 .isEqualTo(existingAdminBundle.toString()); 1231 } 1232 testUpdateProvisioningParamsFromIntent_validDisclaimersWithWorkProfile_works()1233 public void testUpdateProvisioningParamsFromIntent_validDisclaimersWithWorkProfile_works() { 1234 Intent resultIntent = createResultIntentWithManagedProfile() 1235 .putExtra(EXTRA_PROVISIONING_DISCLAIMERS, DISCLAIMERS_EXTRA); 1236 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1237 .build(); 1238 initiateProvisioning(params); 1239 1240 mController.updateProvisioningParamsFromIntent(resultIntent); 1241 1242 assertThat(mController.getParams().disclaimersParam).isEqualTo(DISCLAIMERS_PARAM); 1243 } 1244 testUpdateProvisioningParamsFromIntent_validDisclaimersWithDeviceOwner_works()1245 public void testUpdateProvisioningParamsFromIntent_validDisclaimersWithDeviceOwner_works() { 1246 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1247 .putExtra(EXTRA_PROVISIONING_DISCLAIMERS, DISCLAIMERS_EXTRA); 1248 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1249 .build(); 1250 initiateProvisioning(params); 1251 1252 mController.updateProvisioningParamsFromIntent(resultIntent); 1253 1254 assertThat(mController.getParams().disclaimersParam).isEqualTo(DISCLAIMERS_PARAM); 1255 } 1256 testUpdateProvisioningParamsFromIntent_noDisclaimersSet_isNull()1257 public void testUpdateProvisioningParamsFromIntent_noDisclaimersSet_isNull() { 1258 Intent resultIntent = createResultIntentWithManagedProfile(); 1259 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1260 .build(); 1261 initiateProvisioning(params); 1262 1263 mController.updateProvisioningParamsFromIntent(resultIntent); 1264 1265 assertThat(mController.getParams().disclaimersParam).isNull(); 1266 } 1267 testUpdateProvisioningParamsFromIntent_withPreExistingDisclaimers_replaced()1268 public void testUpdateProvisioningParamsFromIntent_withPreExistingDisclaimers_replaced() { 1269 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1270 .putExtra(EXTRA_PROVISIONING_DISCLAIMERS, DISCLAIMERS_EXTRA); 1271 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1272 .setDisclaimersParam(OTHER_DISCLAIMERS_PARAM) 1273 .build(); 1274 initiateProvisioning(params); 1275 1276 mController.updateProvisioningParamsFromIntent(resultIntent); 1277 1278 assertThat(mController.getParams().disclaimersParam).isEqualTo(DISCLAIMERS_PARAM); 1279 } 1280 testUpdateProvisioningParamsFromIntent_validLocaleWithWorkProfile_ignored()1281 public void testUpdateProvisioningParamsFromIntent_validLocaleWithWorkProfile_ignored() { 1282 Intent resultIntent = createResultIntentWithManagedProfile() 1283 .putExtra(EXTRA_PROVISIONING_LOCALE, LOCALE_EXTRA); 1284 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1285 .build(); 1286 initiateProvisioning(params); 1287 1288 mController.updateProvisioningParamsFromIntent(resultIntent); 1289 1290 assertThat(mController.getParams().locale).isNull(); 1291 } 1292 testUpdateProvisioningParamsFromIntent_validLocaleWithDeviceOwner_works()1293 public void testUpdateProvisioningParamsFromIntent_validLocaleWithDeviceOwner_works() { 1294 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1295 .putExtra(EXTRA_PROVISIONING_LOCALE, LOCALE_EXTRA); 1296 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1297 .build(); 1298 initiateProvisioning(params); 1299 1300 mController.updateProvisioningParamsFromIntent(resultIntent); 1301 1302 assertThat(mController.getParams().locale).isEqualTo(LOCALE); 1303 } 1304 testUpdateProvisioningParamsFromIntent_noLocaleSet_isNull()1305 public void testUpdateProvisioningParamsFromIntent_noLocaleSet_isNull() { 1306 Intent resultIntent = createResultIntentWithManagedProfile(); 1307 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1308 .build(); 1309 initiateProvisioning(params); 1310 1311 mController.updateProvisioningParamsFromIntent(resultIntent); 1312 1313 assertThat(mController.getParams().locale).isNull(); 1314 } 1315 testUpdateProvisioningParamsFromIntent_withPreExistingLocale_replaced()1316 public void testUpdateProvisioningParamsFromIntent_withPreExistingLocale_replaced() { 1317 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1318 .putExtra(EXTRA_PROVISIONING_LOCALE, LOCALE_EXTRA); 1319 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1320 .setLocale(OTHER_LOCALE) 1321 .build(); 1322 initiateProvisioning(params); 1323 1324 mController.updateProvisioningParamsFromIntent(resultIntent); 1325 1326 assertThat(mController.getParams().locale).isEqualTo(LOCALE); 1327 } 1328 testUpdateProvisioningParamsFromIntent_invalidLocale_ignored()1329 public void testUpdateProvisioningParamsFromIntent_invalidLocale_ignored() { 1330 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1331 .putExtra(EXTRA_PROVISIONING_LOCALE, INVALID_LOCALE_EXTRA); 1332 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1333 .build(); 1334 initiateProvisioning(params); 1335 1336 mController.updateProvisioningParamsFromIntent(resultIntent); 1337 1338 assertThat(mController.getParams().locale).isNull(); 1339 } 1340 testUpdateProvisioningParamsFromIntent_localTimeWithWorkProfile_ignored()1341 public void testUpdateProvisioningParamsFromIntent_localTimeWithWorkProfile_ignored() { 1342 Intent resultIntent = createResultIntentWithManagedProfile() 1343 .putExtra(EXTRA_PROVISIONING_LOCAL_TIME, LOCAL_TIME_EXTRA); 1344 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1345 .build(); 1346 initiateProvisioning(params); 1347 1348 mController.updateProvisioningParamsFromIntent(resultIntent); 1349 1350 assertThat(mController.getParams().localTime).isEqualTo(DEFAULT_LOCAL_TIME); 1351 } 1352 testUpdateProvisioningParamsFromIntent_localTimeWithDeviceOwner_works()1353 public void testUpdateProvisioningParamsFromIntent_localTimeWithDeviceOwner_works() { 1354 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1355 .putExtra(EXTRA_PROVISIONING_LOCAL_TIME, LOCAL_TIME_EXTRA); 1356 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1357 .build(); 1358 initiateProvisioning(params); 1359 1360 mController.updateProvisioningParamsFromIntent(resultIntent); 1361 1362 assertThat(mController.getParams().localTime).isEqualTo(LOCAL_TIME_EXTRA); 1363 } 1364 testUpdateProvisioningParamsFromIntent_noLocalTimeSet_isDefaultLocalTime()1365 public void testUpdateProvisioningParamsFromIntent_noLocalTimeSet_isDefaultLocalTime() { 1366 Intent resultIntent = createResultIntentWithManagedProfile(); 1367 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1368 .build(); 1369 initiateProvisioning(params); 1370 1371 mController.updateProvisioningParamsFromIntent(resultIntent); 1372 1373 assertThat(mController.getParams().localTime).isEqualTo(DEFAULT_LOCAL_TIME); 1374 } 1375 testUpdateProvisioningParamsFromIntent_withPreExistingLocalTime_replaced()1376 public void testUpdateProvisioningParamsFromIntent_withPreExistingLocalTime_replaced() { 1377 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1378 .putExtra(EXTRA_PROVISIONING_LOCAL_TIME, LOCAL_TIME_EXTRA); 1379 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1380 .setLocalTime(OTHER_LOCAL_TIME) 1381 .build(); 1382 initiateProvisioning(params); 1383 1384 mController.updateProvisioningParamsFromIntent(resultIntent); 1385 1386 assertThat(mController.getParams().localTime).isEqualTo(LOCAL_TIME_EXTRA); 1387 } 1388 testUpdateProvisioningParamsFromIntent_timeZoneWithWorkProfile_ignored()1389 public void testUpdateProvisioningParamsFromIntent_timeZoneWithWorkProfile_ignored() { 1390 Intent resultIntent = createResultIntentWithManagedProfile() 1391 .putExtra(EXTRA_PROVISIONING_TIME_ZONE, TIME_ZONE_EXTRA); 1392 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1393 .build(); 1394 initiateProvisioning(params); 1395 1396 mController.updateProvisioningParamsFromIntent(resultIntent); 1397 1398 assertThat(mController.getParams().timeZone).isNull(); 1399 } 1400 testUpdateProvisioningParamsFromIntent_timeZoneWithDeviceOwner_works()1401 public void testUpdateProvisioningParamsFromIntent_timeZoneWithDeviceOwner_works() { 1402 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1403 .putExtra(EXTRA_PROVISIONING_TIME_ZONE, TIME_ZONE_EXTRA); 1404 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1405 .build(); 1406 initiateProvisioning(params); 1407 1408 mController.updateProvisioningParamsFromIntent(resultIntent); 1409 1410 assertThat(mController.getParams().timeZone).isEqualTo(TIME_ZONE_EXTRA); 1411 } 1412 testUpdateProvisioningParamsFromIntent_noTimeZoneSet_isNull()1413 public void testUpdateProvisioningParamsFromIntent_noTimeZoneSet_isNull() { 1414 Intent resultIntent = createResultIntentWithManagedProfile(); 1415 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1416 .build(); 1417 initiateProvisioning(params); 1418 1419 mController.updateProvisioningParamsFromIntent(resultIntent); 1420 1421 assertThat(mController.getParams().timeZone).isNull(); 1422 } 1423 testUpdateProvisioningParamsFromIntent_withPreExistingTimeZone_replaced()1424 public void testUpdateProvisioningParamsFromIntent_withPreExistingTimeZone_replaced() { 1425 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1426 .putExtra(EXTRA_PROVISIONING_TIME_ZONE, TIME_ZONE_EXTRA); 1427 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1428 .setTimeZone(OTHER_TIME_ZONE) 1429 .build(); 1430 initiateProvisioning(params); 1431 1432 mController.updateProvisioningParamsFromIntent(resultIntent); 1433 1434 assertThat(mController.getParams().timeZone).isEqualTo(TIME_ZONE_EXTRA); 1435 } 1436 testUpdateProvisioningParamsFromIntent_skipEncryptionWithWorkProfile_works()1437 public void testUpdateProvisioningParamsFromIntent_skipEncryptionWithWorkProfile_works() { 1438 Intent resultIntent = createResultIntentWithManagedProfile() 1439 .putExtra(EXTRA_PROVISIONING_SKIP_ENCRYPTION, /* value= */ true); 1440 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1441 .build(); 1442 initiateProvisioning(params); 1443 1444 mController.updateProvisioningParamsFromIntent(resultIntent); 1445 1446 assertThat(mController.getParams().skipEncryption).isTrue(); 1447 } 1448 testUpdateProvisioningParamsFromIntent_skipEncryptionWithDeviceOwner_works()1449 public void testUpdateProvisioningParamsFromIntent_skipEncryptionWithDeviceOwner_works() { 1450 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1451 .putExtra(EXTRA_PROVISIONING_SKIP_ENCRYPTION, /* value= */ true); 1452 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1453 .build(); 1454 initiateProvisioning(params); 1455 1456 mController.updateProvisioningParamsFromIntent(resultIntent); 1457 1458 assertThat(mController.getParams().skipEncryption).isTrue(); 1459 } 1460 testUpdateProvisioningParamsFromIntent_noSkipEncryptionSet_isFalse()1461 public void testUpdateProvisioningParamsFromIntent_noSkipEncryptionSet_isFalse() { 1462 Intent resultIntent = createResultIntentWithManagedProfile(); 1463 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1464 .build(); 1465 initiateProvisioning(params); 1466 1467 mController.updateProvisioningParamsFromIntent(resultIntent); 1468 1469 assertThat(mController.getParams().skipEncryption).isFalse(); 1470 } 1471 testUpdateProvisioningParamsFromIntent_withPreExistingSkipEncryption_replaced()1472 public void testUpdateProvisioningParamsFromIntent_withPreExistingSkipEncryption_replaced() { 1473 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1474 .putExtra(EXTRA_PROVISIONING_SKIP_ENCRYPTION, true); 1475 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1476 .setSkipEncryption(false) 1477 .build(); 1478 initiateProvisioning(params); 1479 1480 mController.updateProvisioningParamsFromIntent(resultIntent); 1481 1482 assertThat(mController.getParams().skipEncryption).isTrue(); 1483 } 1484 testUpdateProvisioningParamsFromIntent_deviceOwnerPermissionGrantOptOutWithWorkProfile_ignored()1485 public void testUpdateProvisioningParamsFromIntent_deviceOwnerPermissionGrantOptOutWithWorkProfile_ignored() { 1486 Intent resultIntent = createResultIntentWithManagedProfile() 1487 .putExtra(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT, /* value= */ true); 1488 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1489 .build(); 1490 initiateProvisioning(params); 1491 1492 mController.updateProvisioningParamsFromIntent(resultIntent); 1493 1494 assertThat(mController.getParams().deviceOwnerPermissionGrantOptOut).isFalse(); 1495 } 1496 testUpdateProvisioningParamsFromIntent_deviceOwnerPermissionGrantOptOutWithDeviceOwner_works()1497 public void testUpdateProvisioningParamsFromIntent_deviceOwnerPermissionGrantOptOutWithDeviceOwner_works() { 1498 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1499 .putExtra(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT, /* value= */ true); 1500 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1501 .build(); 1502 initiateProvisioning(params); 1503 1504 mController.updateProvisioningParamsFromIntent(resultIntent); 1505 1506 assertThat(mController.getParams().deviceOwnerPermissionGrantOptOut).isTrue(); 1507 } 1508 testUpdateProvisioningParamsFromIntent_noDeviceOwnerPermissionGrantOptOutSet_isFalse()1509 public void testUpdateProvisioningParamsFromIntent_noDeviceOwnerPermissionGrantOptOutSet_isFalse() { 1510 Intent resultIntent = createResultIntentWithManagedProfile(); 1511 ProvisioningParams params = createProvisioningParamsBuilderForManagedProfile() 1512 .build(); 1513 initiateProvisioning(params); 1514 1515 mController.updateProvisioningParamsFromIntent(resultIntent); 1516 1517 assertThat(mController.getParams().deviceOwnerPermissionGrantOptOut).isFalse(); 1518 } 1519 testUpdateProvisioningParamsFromIntent_withPreExistingDeviceOwnerPermissionGrantOptOut_replaced()1520 public void testUpdateProvisioningParamsFromIntent_withPreExistingDeviceOwnerPermissionGrantOptOut_replaced() { 1521 Intent resultIntent = createResultIntentWithFullyManagedDevice() 1522 .putExtra(EXTRA_PROVISIONING_SENSORS_PERMISSION_GRANT_OPT_OUT, /* value= */ true); 1523 ProvisioningParams params = createProvisioningParamsBuilderForFullyManagedDevice() 1524 .setDeviceOwnerPermissionGrantOptOut(false) 1525 .build(); 1526 initiateProvisioning(params); 1527 1528 mController.updateProvisioningParamsFromIntent(resultIntent); 1529 1530 assertThat(mController.getParams().deviceOwnerPermissionGrantOptOut).isTrue(); 1531 } 1532 testInitiateProvisioning_withActionProvisionManagedDevice_failsSilently()1533 public void testInitiateProvisioning_withActionProvisionManagedDevice_failsSilently() 1534 throws Exception { 1535 prepareMocksForDoIntent(/* skipEncryption= */ false); 1536 1537 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> { 1538 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE); 1539 }); 1540 1541 verify(mUi, never()).initiateUi(any()); 1542 verify(mUi).abortProvisioning(); 1543 verifyNoMoreInteractions(mUi); 1544 } 1545 createDisclaimersExtra()1546 private static Parcelable[] createDisclaimersExtra() { 1547 Bundle disclaimer = new Bundle(); 1548 disclaimer.putString( 1549 EXTRA_PROVISIONING_DISCLAIMER_HEADER, DISCLAIMER_HEADER); 1550 disclaimer.putParcelable(EXTRA_PROVISIONING_DISCLAIMER_CONTENT, DISCLAIMER_CONTENT_URI); 1551 return new Parcelable[]{ disclaimer }; 1552 } 1553 createProvisioningParamsBuilderForInitiateProvisioning()1554 private ProvisioningParams.Builder createProvisioningParamsBuilderForInitiateProvisioning() { 1555 return createProvisioningParamsBuilder() 1556 .setDeviceAdminDownloadInfo(PACKAGE_DOWNLOAD_INFO); 1557 } 1558 prepareMocksForManagedProfileIntent(boolean skipEncryption)1559 private void prepareMocksForManagedProfileIntent(boolean skipEncryption) throws Exception { 1560 final String action = ACTION_PROVISION_MANAGED_PROFILE; 1561 when(mIntent.getAction()).thenReturn(action); 1562 when(mUtils.findDeviceAdmin(TEST_MDM_PACKAGE, null, mContext, UserHandle.myUserId())) 1563 .thenReturn(TEST_MDM_COMPONENT_NAME); 1564 when(mSettingsFacade.isDeviceProvisioned(mContext)).thenReturn(true); 1565 when(mDevicePolicyManager.checkProvisioningPreCondition(action, TEST_MDM_PACKAGE)) 1566 .thenReturn(CODE_OK); 1567 when(mMessageParser.parse(mIntent)).thenReturn( 1568 createParams(false, skipEncryption, null, action, TEST_MDM_PACKAGE)); 1569 } 1570 prepareMocksForNfcIntent(String action, boolean skipEncryption)1571 private void prepareMocksForNfcIntent(String action, boolean skipEncryption) throws Exception { 1572 when(mIntent.getAction()).thenReturn(ACTION_NDEF_DISCOVERED); 1573 when(mIntent.getComponent()).thenReturn(ComponentName.createRelative(MP_PACKAGE_NAME, 1574 ".PreProvisioningActivityViaNfc")); 1575 when(mDevicePolicyManager.checkProvisioningPreCondition(action, TEST_MDM_PACKAGE)) 1576 .thenReturn(CODE_OK); 1577 mParams = createParamsBuilder(true, skipEncryption, TEST_WIFI_SSID, action, 1578 TEST_MDM_PACKAGE) 1579 .setIsNfc(true) 1580 .build(); 1581 when(mMessageParser.parse(mIntent)).thenReturn(mParams); 1582 } 1583 prepareMocksForQrIntent(String action, boolean skipEncryption)1584 private void prepareMocksForQrIntent(String action, boolean skipEncryption) throws Exception { 1585 when(mIntent.getAction()) 1586 .thenReturn(ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE); 1587 when(mIntent.getComponent()).thenReturn(ComponentName.createRelative(MP_PACKAGE_NAME, 1588 ".PreProvisioningActivityViaTrustedApp")); 1589 when(mDevicePolicyManager.checkProvisioningPreCondition(action, TEST_MDM_PACKAGE)) 1590 .thenReturn(CODE_OK); 1591 when(mMessageParser.parse(mIntent)).thenReturn( 1592 createParams(true, skipEncryption, TEST_WIFI_SSID, action, TEST_MDM_PACKAGE)); 1593 } 1594 prepareMocksForDoIntent(boolean skipEncryption)1595 private void prepareMocksForDoIntent(boolean skipEncryption) throws Exception { 1596 final String action = ACTION_PROVISION_MANAGED_DEVICE; 1597 when(mIntent.getAction()).thenReturn(action); 1598 when(mDevicePolicyManager.checkProvisioningPreCondition(action, TEST_MDM_PACKAGE)) 1599 .thenReturn(CODE_OK); 1600 when(mMessageParser.parse(mIntent)).thenReturn( 1601 createParams(false, skipEncryption, TEST_WIFI_SSID, action, TEST_MDM_PACKAGE)); 1602 } 1603 prepareMocksForAfterEncryption(String action, boolean startedByTrustedSource)1604 private void prepareMocksForAfterEncryption(String action, boolean startedByTrustedSource) 1605 throws Exception { 1606 when(mIntent.getAction()).thenReturn(ACTION_RESUME_PROVISIONING); 1607 when(mIntent.getComponent()).thenReturn(ComponentName.createRelative(MP_PACKAGE_NAME, 1608 ".PreProvisioningActivityAfterEncryption")); 1609 when(mDevicePolicyManager.checkProvisioningPreCondition(action, TEST_MDM_PACKAGE)) 1610 .thenReturn(CODE_OK); 1611 when(mMessageParser.parse(mIntent)).thenReturn( 1612 createParams( 1613 startedByTrustedSource, false, TEST_WIFI_SSID, action, TEST_MDM_PACKAGE)); 1614 } 1615 createParamsBuilder( boolean startedByTrustedSource, boolean skipEncryption, String wifiSsid, String action, String packageName)1616 private ProvisioningParams.Builder createParamsBuilder( 1617 boolean startedByTrustedSource, boolean skipEncryption, 1618 String wifiSsid, String action, String packageName) { 1619 ProvisioningParams.Builder builder = ProvisioningParams.Builder.builder() 1620 .setStartedByTrustedSource(startedByTrustedSource) 1621 .setSkipEncryption(skipEncryption) 1622 .setProvisioningAction(action) 1623 .setDeviceAdminPackageName(packageName); 1624 if (!TextUtils.isEmpty(wifiSsid)) { 1625 builder.setWifiInfo(WifiInfo.Builder.builder().setSsid(wifiSsid).build()); 1626 } 1627 return builder; 1628 } 1629 createParams(boolean startedByTrustedSource, boolean skipEncryption, String wifiSsid, String action, String packageName)1630 private ProvisioningParams createParams(boolean startedByTrustedSource, boolean skipEncryption, 1631 String wifiSsid, String action, String packageName) { 1632 return mParams = createParamsBuilder( 1633 startedByTrustedSource, skipEncryption, wifiSsid, action, packageName).build(); 1634 } 1635 verifyInitiateProfileOwnerUi()1636 private void verifyInitiateProfileOwnerUi() { 1637 verify(mUi).initiateUi(any()); 1638 } 1639 verifyInitiateDeviceOwnerUi()1640 private void verifyInitiateDeviceOwnerUi() { 1641 verify(mUi).initiateUi(any()); 1642 } 1643 createProvisioningParamsBuilder()1644 private ProvisioningParams.Builder createProvisioningParamsBuilder() { 1645 return ProvisioningParams.Builder.builder() 1646 .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE) 1647 .setStartedByTrustedSource(true) 1648 .setDeviceAdminComponentName(TEST_MDM_COMPONENT_NAME); 1649 } 1650 initiateProvisioning(ProvisioningParams params)1651 private void initiateProvisioning(ProvisioningParams params) { 1652 try { 1653 when(mMessageParser.parse(any(Intent.class))).thenReturn(params); 1654 } catch (IllegalProvisioningArgumentException e) { 1655 // will never happen 1656 } 1657 InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> 1658 mController.initiateProvisioning(mIntent, TEST_MDM_PACKAGE)); 1659 } 1660 createProvisioningParamsBuilderForFullyManagedDevice()1661 private ProvisioningParams.Builder createProvisioningParamsBuilderForFullyManagedDevice() { 1662 return createProvisioningParamsBuilderForInitiateProvisioning() 1663 .setAllowedProvisioningModes(new ArrayList<>(List.of( 1664 PROVISIONING_MODE_FULLY_MANAGED_DEVICE 1665 ))); 1666 } 1667 createProvisioningParamsBuilderForManagedProfile()1668 private ProvisioningParams.Builder createProvisioningParamsBuilderForManagedProfile() { 1669 return createProvisioningParamsBuilderForInitiateProvisioning() 1670 .setAllowedProvisioningModes(new ArrayList<>(List.of( 1671 PROVISIONING_MODE_MANAGED_PROFILE 1672 ))); 1673 } 1674 createResultIntentWithManagedProfile()1675 private Intent createResultIntentWithManagedProfile() { 1676 return new Intent() 1677 .putExtra(EXTRA_PROVISIONING_MODE, PROVISIONING_MODE_MANAGED_PROFILE); 1678 } 1679 createResultIntentWithFullyManagedDevice()1680 private Intent createResultIntentWithFullyManagedDevice() { 1681 return new Intent() 1682 .putExtra(EXTRA_PROVISIONING_MODE, PROVISIONING_MODE_FULLY_MANAGED_DEVICE); 1683 } 1684 } 1685