1 /* 2 * Copyright (C) 2020 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.settings.users; 18 19 import static android.os.UserManager.SWITCHABILITY_STATUS_OK; 20 import static android.os.UserManager.SWITCHABILITY_STATUS_USER_IN_CALL; 21 import static android.os.UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED; 22 23 import static com.google.common.truth.Truth.assertThat; 24 25 import static org.junit.Assume.assumeTrue; 26 import static org.mockito.ArgumentMatchers.any; 27 import static org.mockito.ArgumentMatchers.anyInt; 28 import static org.mockito.ArgumentMatchers.anyString; 29 import static org.mockito.ArgumentMatchers.eq; 30 import static org.mockito.Mockito.doNothing; 31 import static org.mockito.Mockito.doReturn; 32 import static org.mockito.Mockito.mock; 33 import static org.mockito.Mockito.never; 34 import static org.mockito.Mockito.spy; 35 import static org.mockito.Mockito.verify; 36 import static org.mockito.Mockito.verifyNoMoreInteractions; 37 import static org.robolectric.Shadows.shadowOf; 38 39 import android.app.admin.DevicePolicyManager; 40 import android.app.settings.SettingsEnums; 41 import android.content.ComponentName; 42 import android.content.Context; 43 import android.content.Intent; 44 import android.content.pm.UserInfo; 45 import android.multiuser.Flags; 46 import android.os.Bundle; 47 import android.os.UserHandle; 48 import android.os.UserManager; 49 import android.platform.test.annotations.RequiresFlagsEnabled; 50 import android.platform.test.flag.junit.CheckFlagsRule; 51 import android.platform.test.flag.junit.DeviceFlagsValueProvider; 52 import android.telephony.TelephonyManager; 53 54 import androidx.fragment.app.FragmentActivity; 55 import androidx.preference.Preference; 56 import androidx.preference.PreferenceScreen; 57 import androidx.preference.SwitchPreference; 58 59 import com.android.settings.R; 60 import com.android.settings.SettingsActivity; 61 import com.android.settings.SubSettings; 62 import com.android.settings.testutils.shadow.ShadowDevicePolicyManager; 63 import com.android.settings.testutils.shadow.ShadowUserManager; 64 import com.android.settingslib.RestrictedLockUtils; 65 import com.android.settingslib.RestrictedPreference; 66 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; 67 68 import org.junit.After; 69 import org.junit.Before; 70 import org.junit.Rule; 71 import org.junit.Test; 72 import org.junit.runner.RunWith; 73 import org.mockito.Mock; 74 import org.mockito.MockitoAnnotations; 75 import org.robolectric.RobolectricTestRunner; 76 import org.robolectric.RuntimeEnvironment; 77 import org.robolectric.android.controller.ActivityController; 78 import org.robolectric.annotation.Config; 79 import org.robolectric.shadow.api.Shadow; 80 import org.robolectric.shadows.ShadowIntent; 81 import org.robolectric.util.ReflectionHelpers; 82 83 import java.util.ArrayList; 84 import java.util.List; 85 86 @RunWith(RobolectricTestRunner.class) 87 @Config(shadows = { 88 ShadowUserManager.class, 89 com.android.settings.testutils.shadow.ShadowFragment.class, 90 ShadowDevicePolicyManager.class 91 }) 92 public class UserDetailsSettingsTest { 93 94 private static final String KEY_GRANT_ADMIN = "user_grant_admin"; 95 private static final String KEY_SWITCH_USER = "switch_user"; 96 private static final String KEY_ENABLE_TELEPHONY = "enable_calling"; 97 private static final String KEY_REMOVE_USER = "remove_user"; 98 private static final String KEY_APP_AND_CONTENT_ACCESS = "app_and_content_access"; 99 private static final String KEY_APP_COPYING = "app_copying"; 100 101 private static final int DIALOG_CONFIRM_REMOVE = 1; 102 private static final int DIALOG_CONFIRM_RESET_GUEST = 4; 103 104 @Mock 105 private TelephonyManager mTelephonyManager; 106 107 private ShadowUserManager mUserManager; 108 109 @Mock 110 private RestrictedPreference mSwitchUserPref; 111 @Mock 112 private SwitchPreference mPhonePref; 113 @Mock 114 private SwitchPreference mGrantAdminPref; 115 @Mock 116 private Preference mRemoveUserPref; 117 @Mock 118 private Preference mAppAndContentAccessPref; 119 @Mock 120 private Preference mAppCopyingPref; 121 122 private FragmentActivity mActivity; 123 private Context mContext; 124 private UserCapabilities mUserCapabilities; 125 @Mock 126 private MetricsFeatureProvider mMetricsFeatureProvider; 127 private UserDetailsSettings mFragment; 128 private Bundle mArguments; 129 private UserInfo mUserInfo; 130 131 @Rule 132 public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); 133 @Before setUp()134 public void setUp() { 135 MockitoAnnotations.initMocks(this); 136 137 mActivity = spy(ActivityController.of(new FragmentActivity()).get()); 138 mContext = spy(RuntimeEnvironment.application); 139 mUserCapabilities = UserCapabilities.create(mContext); 140 mUserCapabilities.mUserSwitcherEnabled = true; 141 mFragment = spy(new UserDetailsSettings()); 142 mArguments = new Bundle(); 143 144 UserManager userManager = (UserManager) mContext.getSystemService( 145 Context.USER_SERVICE); 146 mUserManager = Shadow.extract(userManager); 147 148 doReturn(mTelephonyManager).when(mActivity).getSystemService(Context.TELEPHONY_SERVICE); 149 150 ReflectionHelpers.setField(mFragment, "mUserManager", userManager); 151 ReflectionHelpers.setField(mFragment, "mUserCaps", mUserCapabilities); 152 ReflectionHelpers.setField(mFragment, "mMetricsFeatureProvider", mMetricsFeatureProvider); 153 doReturn(mActivity).when(mFragment).getActivity(); 154 doReturn(mActivity).when(mFragment).getContext(); 155 156 doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen(); 157 158 doReturn(mSwitchUserPref).when(mFragment).findPreference(KEY_SWITCH_USER); 159 doReturn(mGrantAdminPref).when(mFragment).findPreference(KEY_GRANT_ADMIN); 160 doReturn(mPhonePref).when(mFragment).findPreference(KEY_ENABLE_TELEPHONY); 161 doReturn(mRemoveUserPref).when(mFragment).findPreference(KEY_REMOVE_USER); 162 doReturn(mAppAndContentAccessPref) 163 .when(mFragment).findPreference(KEY_APP_AND_CONTENT_ACCESS); 164 doReturn(mAppCopyingPref).when(mFragment).findPreference(KEY_APP_COPYING); 165 } 166 167 @After tearDown()168 public void tearDown() { 169 ShadowUserManager.reset(); 170 } 171 172 @Test(expected = IllegalStateException.class) initialize_nullArguments_shouldThrowException()173 public void initialize_nullArguments_shouldThrowException() { 174 mFragment.initialize(mActivity, null); 175 } 176 177 @Test(expected = IllegalStateException.class) initialize_emptyArguments_shouldThrowException()178 public void initialize_emptyArguments_shouldThrowException() { 179 mFragment.initialize(mActivity, new Bundle()); 180 } 181 182 @Test initialize_userSelected_shouldSetupSwitchPref()183 public void initialize_userSelected_shouldSetupSwitchPref() { 184 setupSelectedUser(); 185 doReturn("Switch to " + mUserInfo.name) 186 .when(mActivity).getString(anyInt(), anyString()); 187 188 mFragment.initialize(mActivity, mArguments); 189 190 verify(mActivity).getString(com.android.settingslib.R.string.user_switch_to_user, 191 mUserInfo.name); 192 verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name); 193 verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment); 194 verify(mFragment, never()).removePreference(KEY_SWITCH_USER); 195 } 196 197 @Test initialize_guestSelected_shouldSetupSwitchPref()198 public void initialize_guestSelected_shouldSetupSwitchPref() { 199 setupSelectedGuest(); 200 doReturn("Switch to " + mUserInfo.name) 201 .when(mActivity).getString(anyInt(), anyString()); 202 203 mFragment.initialize(mActivity, mArguments); 204 205 verify(mActivity).getString(com.android.settingslib.R.string.user_switch_to_user, 206 mUserInfo.name); 207 verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name); 208 verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment); 209 verify(mFragment, never()).removePreference(KEY_SWITCH_USER); 210 } 211 212 @Test initialize_userSelected_shouldNotShowAppAndContentPref()213 public void initialize_userSelected_shouldNotShowAppAndContentPref() { 214 setupSelectedUser(); 215 216 mFragment.initialize(mActivity, mArguments); 217 218 verify(mFragment).removePreference(KEY_APP_AND_CONTENT_ACCESS); 219 } 220 221 @Test initialize_guestSelected_shouldNotShowAppAndContentPref()222 public void initialize_guestSelected_shouldNotShowAppAndContentPref() { 223 setupSelectedGuest(); 224 225 mFragment.initialize(mActivity, mArguments); 226 227 verify(mFragment).removePreference(KEY_APP_AND_CONTENT_ACCESS); 228 } 229 230 @Test onResume_canSwitch_shouldEnableSwitchPref()231 public void onResume_canSwitch_shouldEnableSwitchPref() { 232 setupSelectedUser(); 233 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK); 234 mFragment.mSwitchUserPref = mSwitchUserPref; 235 mFragment.onAttach(mContext); 236 237 mFragment.onResume(); 238 239 verify(mSwitchUserPref).setEnabled(true); 240 } 241 242 @Test onResume_userInCall_shouldDisableSwitchPref()243 public void onResume_userInCall_shouldDisableSwitchPref() { 244 setupSelectedUser(); 245 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_IN_CALL); 246 mFragment.mSwitchUserPref = mSwitchUserPref; 247 mFragment.onAttach(mContext); 248 249 mFragment.onResume(); 250 251 verify(mSwitchUserPref).setEnabled(false); 252 } 253 254 @Test 255 @RequiresFlagsEnabled({Flags.FLAG_NEW_MULTIUSER_SETTINGS_UX}) onResume_UserSwitcherDisabled_shouldDisableSwitchPref()256 public void onResume_UserSwitcherDisabled_shouldDisableSwitchPref() { 257 setupSelectedUser(); 258 mUserCapabilities.mUserSwitcherEnabled = false; 259 mFragment.mSwitchUserPref = mSwitchUserPref; 260 mFragment.onAttach(mContext); 261 262 mFragment.onResume(); 263 264 verify(mSwitchUserPref).setEnabled(false); 265 } 266 267 @Test onResume_switchDisallowed_shouldDisableSwitchPref()268 public void onResume_switchDisallowed_shouldDisableSwitchPref() { 269 setupSelectedUser(); 270 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED); 271 mFragment.mSwitchUserPref = mSwitchUserPref; 272 mFragment.onAttach(mContext); 273 274 mFragment.onResume(); 275 276 verify(mSwitchUserPref).setEnabled(false); 277 } 278 279 @Test onResume_systemUserLocked_shouldDisableSwitchPref()280 public void onResume_systemUserLocked_shouldDisableSwitchPref() { 281 setupSelectedUser(); 282 mUserManager.setSwitchabilityStatus(UserManager.SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED); 283 mFragment.mSwitchUserPref = mSwitchUserPref; 284 mFragment.onAttach(mContext); 285 286 mFragment.onResume(); 287 288 verify(mSwitchUserPref).setEnabled(false); 289 } 290 291 @Test initialize_adminWithTelephony_shouldShowPhonePreference()292 public void initialize_adminWithTelephony_shouldShowPhonePreference() { 293 setupSelectedUser(); 294 doReturn(true).when(mTelephonyManager).isVoiceCapable(); 295 mUserManager.setIsAdminUser(true); 296 297 mFragment.initialize(mActivity, mArguments); 298 299 verify(mFragment, never()).removePreference(KEY_ENABLE_TELEPHONY); 300 verify(mPhonePref).setOnPreferenceChangeListener(mFragment); 301 } 302 303 @Test initialize_adminNoTelephony_shouldNotShowPhonePreference()304 public void initialize_adminNoTelephony_shouldNotShowPhonePreference() { 305 setupSelectedUser(); 306 doReturn(false).when(mTelephonyManager).isVoiceCapable(); 307 mUserManager.setIsAdminUser(true); 308 doReturn(null).when(mActivity).getSystemService(Context.TELEPHONY_SERVICE); 309 310 mFragment.initialize(mActivity, mArguments); 311 312 verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY); 313 } 314 315 @Test initialize_nonAdminWithTelephony_shouldNotShowPhonePreference()316 public void initialize_nonAdminWithTelephony_shouldNotShowPhonePreference() { 317 setupSelectedUser(); 318 doReturn(true).when(mTelephonyManager).isVoiceCapable(); 319 mUserManager.setIsAdminUser(false); 320 321 mFragment.initialize(mActivity, mArguments); 322 323 verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY); 324 } 325 326 @Test initialize_nonAdmin_shouldNotShowAppAndContentPref()327 public void initialize_nonAdmin_shouldNotShowAppAndContentPref() { 328 setupSelectedUser(); 329 mUserManager.setIsAdminUser(false); 330 331 mFragment.initialize(mActivity, mArguments); 332 333 verify(mFragment).removePreference(KEY_APP_AND_CONTENT_ACCESS); 334 } 335 336 @Test initialize_adminSelectsSecondaryUser_shouldShowRemovePreference()337 public void initialize_adminSelectsSecondaryUser_shouldShowRemovePreference() { 338 setupSelectedUser(); 339 mUserManager.setIsAdminUser(true); 340 341 mFragment.initialize(mActivity, mArguments); 342 343 verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment); 344 verify(mRemoveUserPref).setTitle(R.string.user_remove_user); 345 verify(mFragment, never()).removePreference(KEY_REMOVE_USER); 346 } 347 348 @Test initialize_adminSelectsNewRestrictedUser_shouldOpenAppContentScreen()349 public void initialize_adminSelectsNewRestrictedUser_shouldOpenAppContentScreen() { 350 setupSelectedRestrictedUser(); 351 mUserManager.setIsAdminUser(true); 352 mArguments.putBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, true); 353 354 mFragment.initialize(mActivity, mArguments); 355 356 Intent startedIntent = shadowOf(mActivity).getNextStartedActivity(); 357 ShadowIntent shadowIntent = shadowOf(startedIntent); 358 assertThat(shadowIntent.getIntentClass()).isEqualTo(SubSettings.class); 359 assertThat(startedIntent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT)) 360 .isEqualTo(AppRestrictionsFragment.class.getName()); 361 Bundle arguments = startedIntent.getBundleExtra( 362 SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS); 363 assertThat(arguments).isNotNull(); 364 assertThat(arguments.getInt(AppRestrictionsFragment.EXTRA_USER_ID, 0)) 365 .isEqualTo(mUserInfo.id); 366 assertThat(arguments.getBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, false)) 367 .isEqualTo(true); 368 } 369 370 @Test initialize_adminSelectsRestrictedUser_shouldSetupPreferences()371 public void initialize_adminSelectsRestrictedUser_shouldSetupPreferences() { 372 setupSelectedRestrictedUser(); 373 mUserManager.setIsAdminUser(true); 374 doReturn(true).when(mTelephonyManager).isVoiceCapable(); 375 376 mFragment.initialize(mActivity, mArguments); 377 378 verify(mFragment, never()).removePreference(KEY_REMOVE_USER); 379 verify(mFragment, never()).removePreference(KEY_SWITCH_USER); 380 verify(mFragment, never()).removePreference(KEY_APP_AND_CONTENT_ACCESS); 381 verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY); 382 verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name); 383 verify(mAppAndContentAccessPref).setOnPreferenceClickListener(mFragment); 384 verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment); 385 verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment); 386 } 387 388 @Test initialize_adminSelectsExistingRestrictedUser_shouldNotStartAppAndContentAccess()389 public void initialize_adminSelectsExistingRestrictedUser_shouldNotStartAppAndContentAccess() { 390 setupSelectedRestrictedUser(); 391 mUserManager.setIsAdminUser(true); 392 mArguments.putBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, false); 393 394 mFragment.initialize(mActivity, mArguments); 395 396 verify(mActivity, never()).startActivity(any(Intent.class)); 397 } 398 399 @Test initialize_adminSelectsGuest_shouldShowRemovePreference()400 public void initialize_adminSelectsGuest_shouldShowRemovePreference() { 401 setupSelectedGuest(); 402 mUserManager.setIsAdminUser(true); 403 404 mFragment.initialize(mActivity, mArguments); 405 406 verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment); 407 verify(mRemoveUserPref).setTitle(com.android.settingslib.R.string.guest_exit_guest); 408 verify(mFragment, never()).removePreference(KEY_REMOVE_USER); 409 } 410 411 @Test initialize_nonAdmin_shouldNotShowRemovePreference()412 public void initialize_nonAdmin_shouldNotShowRemovePreference() { 413 setupSelectedUser(); 414 mUserManager.setIsAdminUser(false); 415 416 mFragment.initialize(mActivity, mArguments); 417 418 verify(mFragment).removePreference(KEY_REMOVE_USER); 419 } 420 421 @Test initialize_onMainUser_shouldNotShowRemovePreference()422 public void initialize_onMainUser_shouldNotShowRemovePreference() { 423 setupSelectedMainUser(); 424 mUserManager.setIsAdminUser(true); 425 426 mFragment.initialize(mActivity, mArguments); 427 428 verify(mFragment).removePreference(KEY_REMOVE_USER); 429 } 430 431 @Test initialize_disallowRemoveUserRestriction_shouldNotShowRemovePreference()432 public void initialize_disallowRemoveUserRestriction_shouldNotShowRemovePreference() { 433 setupSelectedUser(); 434 mUserManager.setIsAdminUser(true); 435 mUserManager.addBaseUserRestriction(UserManager.DISALLOW_REMOVE_USER); 436 437 mFragment.initialize(mActivity, mArguments); 438 439 verify(mFragment).removePreference(KEY_REMOVE_USER); 440 } 441 442 @Test initialize_userHasCallRestriction_shouldSetPhoneSwitchUnChecked()443 public void initialize_userHasCallRestriction_shouldSetPhoneSwitchUnChecked() { 444 setupSelectedUser(); 445 mUserManager.setIsAdminUser(true); 446 mUserManager.setUserRestriction(mUserInfo.getUserHandle(), 447 UserManager.DISALLOW_OUTGOING_CALLS, true); 448 449 mFragment.initialize(mActivity, mArguments); 450 451 verify(mPhonePref).setChecked(false); 452 } 453 454 @Test initialize_noCallRestriction_shouldSetPhoneSwitchChecked()455 public void initialize_noCallRestriction_shouldSetPhoneSwitchChecked() { 456 setupSelectedUser(); 457 mUserManager.setIsAdminUser(true); 458 459 mFragment.initialize(mActivity, mArguments); 460 461 verify(mPhonePref).setChecked(true); 462 } 463 464 @Test initialize_switchUserDisallowed_shouldSetAdminDisabledOnSwitchPreference()465 public void initialize_switchUserDisallowed_shouldSetAdminDisabledOnSwitchPreference() { 466 setupSelectedUser(); 467 mUserCapabilities.mDisallowSwitchUser = true; 468 DevicePolicyManager devicePolicyManager = mock(DevicePolicyManager.class); 469 doReturn(devicePolicyManager).when(mActivity) 470 .getSystemService(Context.DEVICE_POLICY_SERVICE); 471 doReturn(mock(ComponentName.class)).when(devicePolicyManager) 472 .getDeviceOwnerComponentOnAnyUser(); 473 474 mFragment.initialize(mActivity, mArguments); 475 476 verify(mSwitchUserPref).setDisabledByAdmin(any(RestrictedLockUtils.EnforcedAdmin.class)); 477 } 478 479 @Test initialize_switchUserAllowed_shouldSetSwitchPreferenceEnabled()480 public void initialize_switchUserAllowed_shouldSetSwitchPreferenceEnabled() { 481 setupSelectedUser(); 482 mUserCapabilities.mDisallowSwitchUser = false; 483 484 mFragment.initialize(mActivity, mArguments); 485 486 verify(mSwitchUserPref).setDisabledByAdmin(null); 487 verify(mSwitchUserPref).setSelectable(true); 488 verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment); 489 } 490 491 @Test onPreferenceClick_switchClicked_canSwitch_shouldSwitch()492 public void onPreferenceClick_switchClicked_canSwitch_shouldSwitch() { 493 setupSelectedUser(); 494 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK); 495 mFragment.mSwitchUserPref = mSwitchUserPref; 496 mFragment.mRemoveUserPref = mRemoveUserPref; 497 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 498 mFragment.mUserInfo = mUserInfo; 499 500 mFragment.onPreferenceClick(mSwitchUserPref); 501 502 verify(mFragment).switchUser(); 503 verify(mMetricsFeatureProvider).action(any(), 504 eq(SettingsEnums.ACTION_SWITCH_TO_USER)); 505 } 506 507 @Test onPreferenceClick_switchToRestrictedClicked_canSwitch_shouldSwitch()508 public void onPreferenceClick_switchToRestrictedClicked_canSwitch_shouldSwitch() { 509 setupSelectedRestrictedUser(); 510 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK); 511 mFragment.mSwitchUserPref = mSwitchUserPref; 512 mFragment.mRemoveUserPref = mRemoveUserPref; 513 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 514 mFragment.mUserInfo = mUserInfo; 515 516 mFragment.onPreferenceClick(mSwitchUserPref); 517 518 verify(mFragment).switchUser(); 519 verify(mMetricsFeatureProvider).action(any(), 520 eq(SettingsEnums.ACTION_SWITCH_TO_RESTRICTED_USER)); 521 } 522 523 @Test onPreferenceClick_switchToGuestClicked_canSwitch_shouldSwitch()524 public void onPreferenceClick_switchToGuestClicked_canSwitch_shouldSwitch() { 525 setupSelectedGuest(); 526 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK); 527 mFragment.mSwitchUserPref = mSwitchUserPref; 528 mFragment.mRemoveUserPref = mRemoveUserPref; 529 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 530 mFragment.mUserInfo = mUserInfo; 531 532 mFragment.onPreferenceClick(mSwitchUserPref); 533 534 verify(mFragment).switchUser(); 535 verify(mMetricsFeatureProvider).action(any(), eq(SettingsEnums.ACTION_SWITCH_TO_GUEST)); 536 } 537 538 @Test onPreferenceClick_switchClicked_canNotSwitch_doNothing()539 public void onPreferenceClick_switchClicked_canNotSwitch_doNothing() { 540 setupSelectedUser(); 541 mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED); 542 mFragment.mSwitchUserPref = mSwitchUserPref; 543 mFragment.mRemoveUserPref = mRemoveUserPref; 544 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 545 mFragment.mUserInfo = mUserInfo; 546 547 mFragment.onPreferenceClick(mSwitchUserPref); 548 549 verify(mFragment, never()).switchUser(); 550 } 551 552 @Test onPreferenceClick_removeGuestClicked_canDelete_shouldShowDialog()553 public void onPreferenceClick_removeGuestClicked_canDelete_shouldShowDialog() { 554 setupSelectedGuest(); 555 mFragment.mUserInfo = mUserInfo; 556 mUserManager.setIsAdminUser(true); 557 mFragment.mSwitchUserPref = mSwitchUserPref; 558 mFragment.mRemoveUserPref = mRemoveUserPref; 559 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 560 doNothing().when(mFragment).showDialog(anyInt()); 561 562 mFragment.onPreferenceClick(mRemoveUserPref); 563 564 verify(mMetricsFeatureProvider).action(any(), eq(SettingsEnums.ACTION_REMOVE_GUEST_USER)); 565 verify(mFragment).canDeleteUser(); 566 verify(mFragment).showDialog(DIALOG_CONFIRM_RESET_GUEST); 567 } 568 569 @Test onPreferenceClick_removeRestrictedClicked_canDelete_shouldShowDialog()570 public void onPreferenceClick_removeRestrictedClicked_canDelete_shouldShowDialog() { 571 setupSelectedRestrictedUser(); 572 mFragment.mUserInfo = mUserInfo; 573 mUserManager.setIsAdminUser(true); 574 mFragment.mSwitchUserPref = mSwitchUserPref; 575 mFragment.mRemoveUserPref = mRemoveUserPref; 576 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 577 doNothing().when(mFragment).showDialog(anyInt()); 578 579 mFragment.onPreferenceClick(mRemoveUserPref); 580 581 verify(mMetricsFeatureProvider) 582 .action(any(), eq(SettingsEnums.ACTION_REMOVE_RESTRICTED_USER)); 583 verify(mFragment).canDeleteUser(); 584 verify(mFragment).showDialog(DIALOG_CONFIRM_REMOVE); 585 } 586 587 @Test onPreferenceClick_removeClicked_canDelete_shouldShowDialog()588 public void onPreferenceClick_removeClicked_canDelete_shouldShowDialog() { 589 setupSelectedUser(); 590 mFragment.mUserInfo = mUserInfo; 591 mUserManager.setIsAdminUser(true); 592 mFragment.mSwitchUserPref = mSwitchUserPref; 593 mFragment.mRemoveUserPref = mRemoveUserPref; 594 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 595 doNothing().when(mFragment).showDialog(anyInt()); 596 597 mFragment.onPreferenceClick(mRemoveUserPref); 598 599 verify(mMetricsFeatureProvider).action(any(), eq(SettingsEnums.ACTION_REMOVE_USER)); 600 verify(mFragment).canDeleteUser(); 601 verify(mFragment).showDialog(DIALOG_CONFIRM_REMOVE); 602 } 603 604 @Test onPreferenceClick_removeClicked_canNotDelete_doNothing()605 public void onPreferenceClick_removeClicked_canNotDelete_doNothing() { 606 setupSelectedUser(); 607 mFragment.mUserInfo = mUserInfo; 608 mUserManager.setIsAdminUser(false); 609 mFragment.mSwitchUserPref = mSwitchUserPref; 610 mFragment.mRemoveUserPref = mRemoveUserPref; 611 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 612 doNothing().when(mFragment).showDialog(anyInt()); 613 614 mFragment.onPreferenceClick(mRemoveUserPref); 615 616 verify(mFragment).canDeleteUser(); 617 verify(mFragment, never()).showDialog(DIALOG_CONFIRM_REMOVE); 618 } 619 620 @Test onPreferenceClick_selectRestrictedUser_appAndContentAccessClicked_startActivity()621 public void onPreferenceClick_selectRestrictedUser_appAndContentAccessClicked_startActivity() { 622 setupSelectedRestrictedUser(); 623 mFragment.mUserInfo = mUserInfo; 624 mUserManager.setIsAdminUser(true); 625 mFragment.mSwitchUserPref = mSwitchUserPref; 626 mFragment.mRemoveUserPref = mRemoveUserPref; 627 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 628 629 mFragment.onPreferenceClick(mAppAndContentAccessPref); 630 631 Intent startedIntent = shadowOf(mActivity).getNextStartedActivity(); 632 ShadowIntent shadowIntent = shadowOf(startedIntent); 633 assertThat(shadowIntent.getIntentClass()).isEqualTo(SubSettings.class); 634 assertThat(startedIntent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT)) 635 .isEqualTo(AppRestrictionsFragment.class.getName()); 636 Bundle arguments = startedIntent.getBundleExtra( 637 SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS); 638 assertThat(arguments.getInt(AppRestrictionsFragment.EXTRA_USER_ID, 0)) 639 .isEqualTo(mUserInfo.id); 640 assertThat(arguments.getBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, true)) 641 .isEqualTo(false); 642 } 643 644 @Test onPreferenceClick_unknownPreferenceClicked_doNothing()645 public void onPreferenceClick_unknownPreferenceClicked_doNothing() { 646 setupSelectedUser(); 647 mFragment.mUserInfo = mUserInfo; 648 mFragment.mSwitchUserPref = mSwitchUserPref; 649 mFragment.mRemoveUserPref = mRemoveUserPref; 650 mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref; 651 652 mFragment.onPreferenceClick(mock(UserPreference.class)); 653 654 verify(mFragment).onPreferenceClick(any()); 655 verifyNoMoreInteractions(mFragment); 656 } 657 658 @Test canDeleteUser_nonAdminUser_shouldReturnFalse()659 public void canDeleteUser_nonAdminUser_shouldReturnFalse() { 660 mUserManager.setIsAdminUser(false); 661 662 boolean result = mFragment.canDeleteUser(); 663 664 assertThat(result).isFalse(); 665 } 666 667 @Test canDeleteUser_onMainUser_shouldReturnFalse()668 public void canDeleteUser_onMainUser_shouldReturnFalse() { 669 setupSelectedMainUser(); 670 mUserManager.setIsAdminUser(true); 671 mFragment.mUserInfo = mUserInfo; 672 673 boolean result = mFragment.canDeleteUser(); 674 675 assertThat(result).isFalse(); 676 } 677 678 @Test canDeleteUser_adminSelectsUser_noRestrictions_shouldReturnTrue()679 public void canDeleteUser_adminSelectsUser_noRestrictions_shouldReturnTrue() { 680 setupSelectedUser(); 681 mUserManager.setIsAdminUser(true); 682 mFragment.mUserInfo = mUserInfo; 683 684 boolean result = mFragment.canDeleteUser(); 685 686 assertThat(result).isTrue(); 687 } 688 689 @Test canDeleteUser_adminSelectsUser_hasRemoveRestriction_shouldReturnFalse()690 public void canDeleteUser_adminSelectsUser_hasRemoveRestriction_shouldReturnFalse() { 691 setupSelectedUser(); 692 mUserManager.setIsAdminUser(true); 693 mFragment.mUserInfo = mUserInfo; 694 ComponentName componentName = new ComponentName("test", "test"); 695 ShadowDevicePolicyManager.getShadow().setDeviceOwnerComponentOnAnyUser(componentName); 696 ShadowDevicePolicyManager.getShadow().setDeviceOwnerUserId(UserHandle.myUserId()); 697 List<UserManager.EnforcingUser> enforcingUsers = new ArrayList<>(); 698 enforcingUsers.add(new UserManager.EnforcingUser(UserHandle.myUserId(), 699 UserManager.RESTRICTION_SOURCE_DEVICE_OWNER)); 700 mUserManager.setUserRestrictionSources( 701 UserManager.DISALLOW_REMOVE_USER, 702 UserHandle.of(UserHandle.myUserId()), 703 enforcingUsers 704 ); 705 706 boolean result = mFragment.canDeleteUser(); 707 708 assertThat(result).isFalse(); 709 } 710 711 @Test initialize_userSelected_shouldShowGrantAdminPref_MultipleAdminEnabled()712 public void initialize_userSelected_shouldShowGrantAdminPref_MultipleAdminEnabled() { 713 assumeTrue(UserManager.isHeadlessSystemUserMode()); 714 setupSelectedUser(); 715 mUserManager.setIsAdminUser(true); 716 ShadowUserManager.setIsMultipleAdminEnabled(true); 717 mFragment.initialize(mActivity, mArguments); 718 verify(mFragment, never()).removePreference(KEY_GRANT_ADMIN); 719 } 720 721 @Test initialize_userSelected_shouldNotShowGrantAdminPref()722 public void initialize_userSelected_shouldNotShowGrantAdminPref() { 723 setupSelectedUser(); 724 mFragment.initialize(mActivity, mArguments); 725 verify(mFragment).removePreference(KEY_GRANT_ADMIN); 726 } 727 728 @Test initialize_restrictUserSelected_shouldNotShowGrantAdminPref_MultipleAdminEnabled()729 public void initialize_restrictUserSelected_shouldNotShowGrantAdminPref_MultipleAdminEnabled() { 730 setupSelectedUser(); 731 ShadowUserManager.setIsMultipleAdminEnabled(true); 732 // target user has DISALLOW_GRANT_ADMIN restriction 733 mUserManager.setUserRestriction(mUserInfo.getUserHandle(), 734 UserManager.DISALLOW_GRANT_ADMIN, true); 735 mFragment.initialize(mActivity, mArguments); 736 verify(mFragment).removePreference(KEY_GRANT_ADMIN); 737 } 738 739 @Test 740 @RequiresFlagsEnabled(Flags.FLAG_UNICORN_MODE_REFACTORING_FOR_HSUM_READ_ONLY) initialize_currentUserRestrict_shouldNotShowGrantAdminPref_MultipleAdminEnabled()741 public void initialize_currentUserRestrict_shouldNotShowGrantAdminPref_MultipleAdminEnabled() { 742 setupSelectedUser(); 743 ShadowUserManager.setIsMultipleAdminEnabled(true); 744 // current user has DISALLOW_GRANT_ADMIN restriction 745 mUserManager.setUserRestriction(mContext.getUser(), 746 UserManager.DISALLOW_GRANT_ADMIN, true); 747 mFragment.initialize(mActivity, mArguments); 748 verify(mFragment).removePreference(KEY_GRANT_ADMIN); 749 } 750 751 @Test initialize_mainUserSelected_shouldShowGrantAdminPref_MultipleAdminEnabled()752 public void initialize_mainUserSelected_shouldShowGrantAdminPref_MultipleAdminEnabled() { 753 setupSelectedMainUser(); 754 ShadowUserManager.setIsMultipleAdminEnabled(true); 755 mFragment.initialize(mActivity, mArguments); 756 verify(mFragment).removePreference(KEY_GRANT_ADMIN); 757 } 758 759 @Test initialize_guestSelected_shouldNotShowGrantAdminPref_MultipleAdminEnabled()760 public void initialize_guestSelected_shouldNotShowGrantAdminPref_MultipleAdminEnabled() { 761 setupSelectedGuest(); 762 ShadowUserManager.setIsMultipleAdminEnabled(true); 763 mFragment.initialize(mActivity, mArguments); 764 verify(mFragment).removePreference(KEY_GRANT_ADMIN); 765 } 766 767 @Test onPreferenceChange_grantAdminClicked_isNotAdmin_shouldLogGrantAdmin()768 public void onPreferenceChange_grantAdminClicked_isNotAdmin_shouldLogGrantAdmin() { 769 setupSelectedUser(); 770 mFragment.mUserInfo = mUserInfo; 771 mFragment.mGrantAdminPref = mGrantAdminPref; 772 doNothing().when(mFragment).showDialog(anyInt()); 773 774 mFragment.onPreferenceChange(mGrantAdminPref, true); 775 776 verify(mMetricsFeatureProvider).action(any(), 777 eq(SettingsEnums.ACTION_GRANT_ADMIN_FROM_SETTINGS)); 778 } 779 780 @Test onPreferenceChange_grantAdminClicked_isAdmin_shouldLogRevokeAdmin()781 public void onPreferenceChange_grantAdminClicked_isAdmin_shouldLogRevokeAdmin() { 782 setupSelectedAdminUser(); 783 mFragment.mUserInfo = mUserInfo; 784 mFragment.mGrantAdminPref = mGrantAdminPref; 785 doNothing().when(mFragment).showDialog(anyInt()); 786 787 mFragment.onPreferenceChange(mGrantAdminPref, false); 788 789 verify(mMetricsFeatureProvider).action(any(), 790 eq(SettingsEnums.ACTION_REVOKE_ADMIN_FROM_SETTINGS)); 791 } 792 setupSelectedUser()793 private void setupSelectedUser() { 794 mArguments.putInt("user_id", 1); 795 mUserInfo = new UserInfo(1, "Tom", null, 796 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED, 797 UserManager.USER_TYPE_FULL_SECONDARY); 798 mFragment.mUserInfo = mUserInfo; 799 mUserManager.addProfile(mUserInfo); 800 } 801 setupSelectedMainUser()802 private void setupSelectedMainUser() { 803 mArguments.putInt("user_id", 11); 804 mUserInfo = new UserInfo(11, "Jerry", null, 805 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_MAIN, 806 UserManager.USER_TYPE_FULL_SECONDARY); 807 mFragment.mUserInfo = mUserInfo; 808 mUserManager.addProfile(mUserInfo); 809 } 810 setupSelectedAdminUser()811 private void setupSelectedAdminUser() { 812 mArguments.putInt("user_id", 12); 813 mUserInfo = new UserInfo(12, "Andy", null, 814 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_ADMIN, 815 UserManager.USER_TYPE_FULL_SECONDARY); 816 mFragment.mUserInfo = mUserInfo; 817 mUserManager.addProfile(mUserInfo); 818 } 819 setupSelectedGuest()820 private void setupSelectedGuest() { 821 mArguments.putInt("user_id", 23); 822 mUserInfo = new UserInfo(23, "Guest", null, 823 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_GUEST, 824 UserManager.USER_TYPE_FULL_GUEST); 825 mFragment.mUserInfo = mUserInfo; 826 mUserManager.addProfile(mUserInfo); 827 } 828 setupSelectedRestrictedUser()829 private void setupSelectedRestrictedUser() { 830 mArguments.putInt("user_id", 21); 831 mUserInfo = new UserInfo(21, "Bob", null, 832 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_RESTRICTED, 833 UserManager.USER_TYPE_FULL_RESTRICTED); 834 mFragment.mUserInfo = mUserInfo; 835 mUserManager.addProfile(mUserInfo); 836 } 837 } 838