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.mockito.ArgumentMatchers.any;
26 import static org.mockito.ArgumentMatchers.anyInt;
27 import static org.mockito.ArgumentMatchers.anyString;
28 import static org.mockito.ArgumentMatchers.eq;
29 import static org.mockito.Mockito.doNothing;
30 import static org.mockito.Mockito.doReturn;
31 import static org.mockito.Mockito.mock;
32 import static org.mockito.Mockito.never;
33 import static org.mockito.Mockito.spy;
34 import static org.mockito.Mockito.verify;
35 import static org.mockito.Mockito.verifyNoMoreInteractions;
36 import static org.robolectric.Shadows.shadowOf;
37 
38 import android.app.admin.DevicePolicyManager;
39 import android.app.settings.SettingsEnums;
40 import android.content.ComponentName;
41 import android.content.Context;
42 import android.content.Intent;
43 import android.content.pm.UserInfo;
44 import android.os.Bundle;
45 import android.os.UserHandle;
46 import android.os.UserManager;
47 import android.telephony.TelephonyManager;
48 
49 import androidx.fragment.app.FragmentActivity;
50 import androidx.preference.Preference;
51 import androidx.preference.PreferenceScreen;
52 import androidx.preference.SwitchPreference;
53 
54 import com.android.settings.R;
55 import com.android.settings.SettingsActivity;
56 import com.android.settings.SubSettings;
57 import com.android.settings.testutils.shadow.ShadowDevicePolicyManager;
58 import com.android.settings.testutils.shadow.ShadowUserManager;
59 import com.android.settingslib.RestrictedLockUtils;
60 import com.android.settingslib.RestrictedPreference;
61 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
62 
63 import org.junit.After;
64 import org.junit.Before;
65 import org.junit.Test;
66 import org.junit.runner.RunWith;
67 import org.mockito.Mock;
68 import org.mockito.MockitoAnnotations;
69 import org.robolectric.RobolectricTestRunner;
70 import org.robolectric.RuntimeEnvironment;
71 import org.robolectric.android.controller.ActivityController;
72 import org.robolectric.annotation.Config;
73 import org.robolectric.shadow.api.Shadow;
74 import org.robolectric.shadows.ShadowIntent;
75 import org.robolectric.util.ReflectionHelpers;
76 
77 import java.util.ArrayList;
78 import java.util.List;
79 
80 @RunWith(RobolectricTestRunner.class)
81 @Config(shadows = {
82         ShadowUserManager.class,
83         ShadowDevicePolicyManager.class
84 })
85 public class UserDetailsSettingsTest {
86 
87     private static final String KEY_SWITCH_USER = "switch_user";
88     private static final String KEY_ENABLE_TELEPHONY = "enable_calling";
89     private static final String KEY_REMOVE_USER = "remove_user";
90     private static final String KEY_APP_AND_CONTENT_ACCESS = "app_and_content_access";
91 
92     private static final int DIALOG_CONFIRM_REMOVE = 1;
93 
94     @Mock
95     private TelephonyManager mTelephonyManager;
96 
97     private ShadowUserManager mUserManager;
98 
99     @Mock
100     private RestrictedPreference mSwitchUserPref;
101     @Mock
102     private SwitchPreference mPhonePref;
103     @Mock
104     private Preference mRemoveUserPref;
105     @Mock
106     private Preference mAppAndContentAccessPref;
107 
108     private FragmentActivity mActivity;
109     private Context mContext;
110     private UserCapabilities mUserCapabilities;
111     @Mock
112     private MetricsFeatureProvider mMetricsFeatureProvider;
113     private UserDetailsSettings mFragment;
114     private Bundle mArguments;
115     private UserInfo mUserInfo;
116 
117     @Before
setUp()118     public void setUp() {
119         MockitoAnnotations.initMocks(this);
120 
121         mActivity = spy(ActivityController.of(new FragmentActivity()).get());
122         mContext = spy(RuntimeEnvironment.application);
123         mUserCapabilities = UserCapabilities.create(mContext);
124         mUserCapabilities.mUserSwitcherEnabled = true;
125         mFragment = spy(new UserDetailsSettings());
126         mArguments = new Bundle();
127 
128         UserManager userManager = (UserManager) mContext.getSystemService(
129                 Context.USER_SERVICE);
130         mUserManager = Shadow.extract(userManager);
131 
132         doReturn(mTelephonyManager).when(mActivity).getSystemService(Context.TELEPHONY_SERVICE);
133 
134         ReflectionHelpers.setField(mFragment, "mUserManager", userManager);
135         ReflectionHelpers.setField(mFragment, "mUserCaps", mUserCapabilities);
136         ReflectionHelpers.setField(mFragment, "mMetricsFeatureProvider", mMetricsFeatureProvider);
137         doReturn(mActivity).when(mFragment).getActivity();
138         doReturn(mActivity).when(mFragment).getContext();
139 
140         doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
141 
142         doReturn(mSwitchUserPref).when(mFragment).findPreference(KEY_SWITCH_USER);
143         doReturn(mPhonePref).when(mFragment).findPreference(KEY_ENABLE_TELEPHONY);
144         doReturn(mRemoveUserPref).when(mFragment).findPreference(KEY_REMOVE_USER);
145         doReturn(mAppAndContentAccessPref)
146                 .when(mFragment).findPreference(KEY_APP_AND_CONTENT_ACCESS);
147     }
148 
149     @After
tearDown()150     public void tearDown() {
151         ShadowUserManager.reset();
152     }
153 
154     @Test(expected = IllegalStateException.class)
initialize_nullArguments_shouldThrowException()155     public void initialize_nullArguments_shouldThrowException() {
156         mFragment.initialize(mActivity, null);
157     }
158 
159     @Test(expected = IllegalStateException.class)
initialize_emptyArguments_shouldThrowException()160     public void initialize_emptyArguments_shouldThrowException() {
161         mFragment.initialize(mActivity, new Bundle());
162     }
163 
164     @Test
initialize_userSelected_shouldSetupSwitchPref()165     public void initialize_userSelected_shouldSetupSwitchPref() {
166         setupSelectedUser();
167         doReturn("Switch to " + mUserInfo.name)
168                 .when(mActivity).getString(anyInt(), anyString());
169 
170         mFragment.initialize(mActivity, mArguments);
171 
172         verify(mActivity).getString(com.android.settingslib.R.string.user_switch_to_user,
173                 mUserInfo.name);
174         verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name);
175         verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment);
176         verify(mFragment, never()).removePreference(KEY_SWITCH_USER);
177     }
178 
179     @Test
initialize_guestSelected_shouldSetupSwitchPref()180     public void initialize_guestSelected_shouldSetupSwitchPref() {
181         setupSelectedGuest();
182         doReturn("Switch to " + mUserInfo.name)
183                 .when(mActivity).getString(anyInt(), anyString());
184 
185         mFragment.initialize(mActivity, mArguments);
186 
187         verify(mActivity).getString(com.android.settingslib.R.string.user_switch_to_user,
188                 mUserInfo.name);
189         verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name);
190         verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment);
191         verify(mFragment, never()).removePreference(KEY_SWITCH_USER);
192     }
193 
194     @Test
initialize_userSelected_shouldNotShowAppAndContentPref()195     public void initialize_userSelected_shouldNotShowAppAndContentPref() {
196         setupSelectedUser();
197 
198         mFragment.initialize(mActivity, mArguments);
199 
200         verify(mFragment).removePreference(KEY_APP_AND_CONTENT_ACCESS);
201     }
202 
203     @Test
initialize_guestSelected_shouldNotShowAppAndContentPref()204     public void initialize_guestSelected_shouldNotShowAppAndContentPref() {
205         setupSelectedGuest();
206 
207         mFragment.initialize(mActivity, mArguments);
208 
209         verify(mFragment).removePreference(KEY_APP_AND_CONTENT_ACCESS);
210     }
211 
212     @Test
onResume_canSwitch_shouldEnableSwitchPref()213     public void onResume_canSwitch_shouldEnableSwitchPref() {
214         mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK);
215         mFragment.mSwitchUserPref = mSwitchUserPref;
216         mFragment.onAttach(mContext);
217 
218         mFragment.onResume();
219 
220         verify(mSwitchUserPref).setEnabled(true);
221     }
222 
223     @Test
onResume_userInCall_shouldDisableSwitchPref()224     public void onResume_userInCall_shouldDisableSwitchPref() {
225         mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_IN_CALL);
226         mFragment.mSwitchUserPref = mSwitchUserPref;
227         mFragment.onAttach(mContext);
228 
229         mFragment.onResume();
230 
231         verify(mSwitchUserPref).setEnabled(false);
232     }
233 
234     @Test
onResume_switchDisallowed_shouldDisableSwitchPref()235     public void onResume_switchDisallowed_shouldDisableSwitchPref() {
236         mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
237         mFragment.mSwitchUserPref = mSwitchUserPref;
238         mFragment.onAttach(mContext);
239 
240         mFragment.onResume();
241 
242         verify(mSwitchUserPref).setEnabled(false);
243     }
244 
245     @Test
onResume_systemUserLocked_shouldDisableSwitchPref()246     public void onResume_systemUserLocked_shouldDisableSwitchPref() {
247         mUserManager.setSwitchabilityStatus(UserManager.SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED);
248         mFragment.mSwitchUserPref = mSwitchUserPref;
249         mFragment.onAttach(mContext);
250 
251         mFragment.onResume();
252 
253         verify(mSwitchUserPref).setEnabled(false);
254     }
255 
256     @Test
initialize_adminWithTelephony_shouldShowPhonePreference()257     public void initialize_adminWithTelephony_shouldShowPhonePreference() {
258         setupSelectedUser();
259         doReturn(true).when(mTelephonyManager).isVoiceCapable();
260         mUserManager.setIsAdminUser(true);
261 
262         mFragment.initialize(mActivity, mArguments);
263 
264         verify(mFragment, never()).removePreference(KEY_ENABLE_TELEPHONY);
265         verify(mPhonePref).setOnPreferenceChangeListener(mFragment);
266     }
267 
268     @Test
initialize_adminNoTelephony_shouldNotShowPhonePreference()269     public void initialize_adminNoTelephony_shouldNotShowPhonePreference() {
270         setupSelectedUser();
271         doReturn(false).when(mTelephonyManager).isVoiceCapable();
272         mUserManager.setIsAdminUser(true);
273         doReturn(null).when(mActivity).getSystemService(Context.TELEPHONY_SERVICE);
274 
275         mFragment.initialize(mActivity, mArguments);
276 
277         verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY);
278     }
279 
280     @Test
initialize_nonAdminWithTelephony_shouldNotShowPhonePreference()281     public void initialize_nonAdminWithTelephony_shouldNotShowPhonePreference() {
282         setupSelectedUser();
283         doReturn(true).when(mTelephonyManager).isVoiceCapable();
284         mUserManager.setIsAdminUser(false);
285 
286         mFragment.initialize(mActivity, mArguments);
287 
288         verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY);
289     }
290 
291     @Test
initialize_nonAdmin_shouldNotShowAppAndContentPref()292     public void initialize_nonAdmin_shouldNotShowAppAndContentPref() {
293         setupSelectedUser();
294         mUserManager.setIsAdminUser(false);
295 
296         mFragment.initialize(mActivity, mArguments);
297 
298         verify(mFragment).removePreference(KEY_APP_AND_CONTENT_ACCESS);
299     }
300 
301     @Test
initialize_adminSelectsSecondaryUser_shouldShowRemovePreference()302     public void initialize_adminSelectsSecondaryUser_shouldShowRemovePreference() {
303         setupSelectedUser();
304         mUserManager.setIsAdminUser(true);
305 
306         mFragment.initialize(mActivity, mArguments);
307 
308         verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment);
309         verify(mRemoveUserPref).setTitle(R.string.user_remove_user);
310         verify(mFragment, never()).removePreference(KEY_REMOVE_USER);
311     }
312 
313     @Test
initialize_adminSelectsNewRestrictedUser_shouldOpenAppContentScreen()314     public void initialize_adminSelectsNewRestrictedUser_shouldOpenAppContentScreen() {
315         setupSelectedRestrictedUser();
316         mUserManager.setIsAdminUser(true);
317         mArguments.putBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, true);
318 
319         mFragment.initialize(mActivity, mArguments);
320 
321         Intent startedIntent = shadowOf(mActivity).getNextStartedActivity();
322         ShadowIntent shadowIntent = shadowOf(startedIntent);
323         assertThat(shadowIntent.getIntentClass()).isEqualTo(SubSettings.class);
324         assertThat(startedIntent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT))
325                 .isEqualTo(AppRestrictionsFragment.class.getName());
326         Bundle arguments = startedIntent.getBundleExtra(
327                 SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS);
328         assertThat(arguments).isNotNull();
329         assertThat(arguments.getInt(AppRestrictionsFragment.EXTRA_USER_ID, 0))
330                 .isEqualTo(mUserInfo.id);
331         assertThat(arguments.getBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, false))
332                 .isEqualTo(true);
333     }
334 
335     @Test
initialize_adminSelectsRestrictedUser_shouldSetupPreferences()336     public void initialize_adminSelectsRestrictedUser_shouldSetupPreferences() {
337         setupSelectedRestrictedUser();
338         mUserManager.setIsAdminUser(true);
339         doReturn(true).when(mTelephonyManager).isVoiceCapable();
340 
341         mFragment.initialize(mActivity, mArguments);
342 
343         verify(mFragment, never()).removePreference(KEY_REMOVE_USER);
344         verify(mFragment, never()).removePreference(KEY_SWITCH_USER);
345         verify(mFragment, never()).removePreference(KEY_APP_AND_CONTENT_ACCESS);
346         verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY);
347         verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name);
348         verify(mAppAndContentAccessPref).setOnPreferenceClickListener(mFragment);
349         verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment);
350         verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment);
351     }
352 
353     @Test
initialize_adminSelectsExistingRestrictedUser_shouldNotStartAppAndContentAccess()354     public void initialize_adminSelectsExistingRestrictedUser_shouldNotStartAppAndContentAccess() {
355         setupSelectedRestrictedUser();
356         mUserManager.setIsAdminUser(true);
357         mArguments.putBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, false);
358 
359         mFragment.initialize(mActivity, mArguments);
360 
361         verify(mActivity, never()).startActivity(any(Intent.class));
362     }
363 
364     @Test
initialize_adminSelectsGuest_shouldShowRemovePreference()365     public void initialize_adminSelectsGuest_shouldShowRemovePreference() {
366         setupSelectedGuest();
367         mUserManager.setIsAdminUser(true);
368 
369         mFragment.initialize(mActivity, mArguments);
370 
371         verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment);
372         verify(mRemoveUserPref).setTitle(R.string.user_exit_guest_title);
373         verify(mFragment, never()).removePreference(KEY_REMOVE_USER);
374     }
375 
376     @Test
initialize_nonAdmin_shouldNotShowRemovePreference()377     public void initialize_nonAdmin_shouldNotShowRemovePreference() {
378         setupSelectedUser();
379         mUserManager.setIsAdminUser(false);
380 
381         mFragment.initialize(mActivity, mArguments);
382 
383         verify(mFragment).removePreference(KEY_REMOVE_USER);
384     }
385 
386     @Test
initialize_disallowRemoveUserRestriction_shouldNotShowRemovePreference()387     public void initialize_disallowRemoveUserRestriction_shouldNotShowRemovePreference() {
388         setupSelectedUser();
389         mUserManager.setIsAdminUser(true);
390         mUserManager.addBaseUserRestriction(UserManager.DISALLOW_REMOVE_USER);
391 
392         mFragment.initialize(mActivity, mArguments);
393 
394         verify(mFragment).removePreference(KEY_REMOVE_USER);
395     }
396 
397     @Test
initialize_userHasCallRestriction_shouldSetPhoneSwitchUnChecked()398     public void initialize_userHasCallRestriction_shouldSetPhoneSwitchUnChecked() {
399         setupSelectedUser();
400         mUserManager.setIsAdminUser(true);
401         mUserManager.setUserRestriction(mUserInfo.getUserHandle(),
402                 UserManager.DISALLOW_OUTGOING_CALLS, true);
403 
404         mFragment.initialize(mActivity, mArguments);
405 
406         verify(mPhonePref).setChecked(false);
407     }
408 
409     @Test
initialize_noCallRestriction_shouldSetPhoneSwitchChecked()410     public void initialize_noCallRestriction_shouldSetPhoneSwitchChecked() {
411         setupSelectedUser();
412         mUserManager.setIsAdminUser(true);
413 
414         mFragment.initialize(mActivity, mArguments);
415 
416         verify(mPhonePref).setChecked(true);
417     }
418 
419     @Test
initialize_guestSelected_noCallRestriction_shouldSetPhonePreference()420     public void initialize_guestSelected_noCallRestriction_shouldSetPhonePreference() {
421         setupSelectedGuest();
422         mUserManager.setIsAdminUser(true);
423 
424         mFragment.initialize(mActivity, mArguments);
425 
426         verify(mPhonePref).setTitle(R.string.user_enable_calling);
427         verify(mPhonePref).setChecked(true);
428     }
429 
430     @Test
initialize_guestSelected_callRestriction_shouldSetPhonePreference()431     public void initialize_guestSelected_callRestriction_shouldSetPhonePreference() {
432         setupSelectedGuest();
433         mUserManager.setIsAdminUser(true);
434         mUserManager.addGuestUserRestriction(UserManager.DISALLOW_OUTGOING_CALLS);
435 
436         mFragment.initialize(mActivity, mArguments);
437 
438         verify(mPhonePref).setTitle(R.string.user_enable_calling);
439         verify(mPhonePref).setChecked(false);
440     }
441 
442     @Test
initialize_switchUserDisallowed_shouldSetAdminDisabledOnSwitchPreference()443     public void initialize_switchUserDisallowed_shouldSetAdminDisabledOnSwitchPreference() {
444         setupSelectedUser();
445         mUserCapabilities.mDisallowSwitchUser = true;
446         DevicePolicyManager devicePolicyManager = mock(DevicePolicyManager.class);
447         doReturn(devicePolicyManager).when(mActivity)
448                 .getSystemService(Context.DEVICE_POLICY_SERVICE);
449         doReturn(mock(ComponentName.class)).when(devicePolicyManager)
450                 .getDeviceOwnerComponentOnAnyUser();
451 
452         mFragment.initialize(mActivity, mArguments);
453 
454         verify(mSwitchUserPref).setDisabledByAdmin(any(RestrictedLockUtils.EnforcedAdmin.class));
455     }
456 
457     @Test
initialize_switchUserAllowed_shouldSetSwitchPreferenceEnabled()458     public void initialize_switchUserAllowed_shouldSetSwitchPreferenceEnabled() {
459         setupSelectedUser();
460         mUserCapabilities.mDisallowSwitchUser = false;
461 
462         mFragment.initialize(mActivity, mArguments);
463 
464         verify(mSwitchUserPref).setDisabledByAdmin(null);
465         verify(mSwitchUserPref).setSelectable(true);
466         verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment);
467     }
468 
469     @Test
onPreferenceClick_switchClicked_canSwitch_shouldSwitch()470     public void onPreferenceClick_switchClicked_canSwitch_shouldSwitch() {
471         setupSelectedUser();
472         mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK);
473         mFragment.mSwitchUserPref = mSwitchUserPref;
474         mFragment.mRemoveUserPref = mRemoveUserPref;
475         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
476         mFragment.mUserInfo = mUserInfo;
477 
478         mFragment.onPreferenceClick(mSwitchUserPref);
479 
480         verify(mFragment).switchUser();
481         verify(mMetricsFeatureProvider, never()).action(any(),
482                 eq(SettingsEnums.ACTION_SWITCH_TO_GUEST));
483     }
484 
485     @Test
onPreferenceClick_switchToGuestClicked_canSwitch_shouldSwitch()486     public void onPreferenceClick_switchToGuestClicked_canSwitch_shouldSwitch() {
487         setupSelectedGuest();
488         mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK);
489         mFragment.mSwitchUserPref = mSwitchUserPref;
490         mFragment.mRemoveUserPref = mRemoveUserPref;
491         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
492         mFragment.mUserInfo = mUserInfo;
493 
494         mFragment.onPreferenceClick(mSwitchUserPref);
495 
496         verify(mFragment).switchUser();
497         verify(mMetricsFeatureProvider).action(any(), eq(SettingsEnums.ACTION_SWITCH_TO_GUEST));
498     }
499 
500     @Test
onPreferenceClick_switchClicked_canNotSwitch_doNothing()501     public void onPreferenceClick_switchClicked_canNotSwitch_doNothing() {
502         setupSelectedUser();
503         mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
504         mFragment.mSwitchUserPref = mSwitchUserPref;
505         mFragment.mRemoveUserPref = mRemoveUserPref;
506         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
507         mFragment.mUserInfo = mUserInfo;
508 
509         mFragment.onPreferenceClick(mSwitchUserPref);
510 
511         verify(mFragment, never()).switchUser();
512     }
513 
514     @Test
onPreferenceClick_removeClicked_canDelete_shouldShowDialog()515     public void onPreferenceClick_removeClicked_canDelete_shouldShowDialog() {
516         setupSelectedUser();
517         mFragment.mUserInfo = mUserInfo;
518         mUserManager.setIsAdminUser(true);
519         mFragment.mSwitchUserPref = mSwitchUserPref;
520         mFragment.mRemoveUserPref = mRemoveUserPref;
521         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
522         doNothing().when(mFragment).showDialog(anyInt());
523 
524         mFragment.onPreferenceClick(mRemoveUserPref);
525 
526         verify(mFragment).canDeleteUser();
527         verify(mFragment).showDialog(DIALOG_CONFIRM_REMOVE);
528     }
529 
530     @Test
onPreferenceClick_removeClicked_canNotDelete_doNothing()531     public void onPreferenceClick_removeClicked_canNotDelete_doNothing() {
532         setupSelectedUser();
533         mFragment.mUserInfo = mUserInfo;
534         mUserManager.setIsAdminUser(false);
535         mFragment.mSwitchUserPref = mSwitchUserPref;
536         mFragment.mRemoveUserPref = mRemoveUserPref;
537         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
538         doNothing().when(mFragment).showDialog(anyInt());
539 
540         mFragment.onPreferenceClick(mRemoveUserPref);
541 
542         verify(mFragment).canDeleteUser();
543         verify(mFragment, never()).showDialog(DIALOG_CONFIRM_REMOVE);
544     }
545 
546     @Test
onPreferenceClick_selectRestrictedUser_appAndContentAccessClicked_startActivity()547     public void onPreferenceClick_selectRestrictedUser_appAndContentAccessClicked_startActivity() {
548         setupSelectedRestrictedUser();
549         mFragment.mUserInfo = mUserInfo;
550         mUserManager.setIsAdminUser(true);
551         mFragment.mSwitchUserPref = mSwitchUserPref;
552         mFragment.mRemoveUserPref = mRemoveUserPref;
553         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
554 
555         mFragment.onPreferenceClick(mAppAndContentAccessPref);
556 
557         Intent startedIntent = shadowOf(mActivity).getNextStartedActivity();
558         ShadowIntent shadowIntent = shadowOf(startedIntent);
559         assertThat(shadowIntent.getIntentClass()).isEqualTo(SubSettings.class);
560         assertThat(startedIntent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT))
561                 .isEqualTo(AppRestrictionsFragment.class.getName());
562         Bundle arguments = startedIntent.getBundleExtra(
563                 SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS);
564         assertThat(arguments.getInt(AppRestrictionsFragment.EXTRA_USER_ID, 0))
565                 .isEqualTo(mUserInfo.id);
566         assertThat(arguments.getBoolean(AppRestrictionsFragment.EXTRA_NEW_USER, true))
567                 .isEqualTo(false);
568     }
569 
570     @Test
onPreferenceClick_unknownPreferenceClicked_doNothing()571     public void onPreferenceClick_unknownPreferenceClicked_doNothing() {
572         setupSelectedUser();
573         mFragment.mUserInfo = mUserInfo;
574         mFragment.mSwitchUserPref = mSwitchUserPref;
575         mFragment.mRemoveUserPref = mRemoveUserPref;
576         mFragment.mAppAndContentAccessPref = mAppAndContentAccessPref;
577 
578         mFragment.onPreferenceClick(mock(UserPreference.class));
579 
580         verify(mFragment).onPreferenceClick(any());
581         verifyNoMoreInteractions(mFragment);
582     }
583 
584     @Test
canDeleteUser_nonAdminUser_shouldReturnFalse()585     public void canDeleteUser_nonAdminUser_shouldReturnFalse() {
586         mUserManager.setIsAdminUser(false);
587 
588         boolean result = mFragment.canDeleteUser();
589 
590         assertThat(result).isFalse();
591     }
592 
593     @Test
canDeleteUser_adminSelectsUser_noRestrictions_shouldReturnTrue()594     public void canDeleteUser_adminSelectsUser_noRestrictions_shouldReturnTrue() {
595         setupSelectedUser();
596         mUserManager.setIsAdminUser(true);
597 
598         boolean result = mFragment.canDeleteUser();
599 
600         assertThat(result).isTrue();
601     }
602 
603     @Test
canDeleteUser_adminSelectsUser_hasRemoveRestriction_shouldReturnFalse()604     public void canDeleteUser_adminSelectsUser_hasRemoveRestriction_shouldReturnFalse() {
605         setupSelectedUser();
606         mUserManager.setIsAdminUser(true);
607         ComponentName componentName = new ComponentName("test", "test");
608         ShadowDevicePolicyManager.getShadow().setDeviceOwnerComponentOnAnyUser(componentName);
609         ShadowDevicePolicyManager.getShadow().setDeviceOwnerUserId(UserHandle.myUserId());
610         List<UserManager.EnforcingUser> enforcingUsers = new ArrayList<>();
611         enforcingUsers.add(new UserManager.EnforcingUser(UserHandle.myUserId(),
612                 UserManager.RESTRICTION_SOURCE_DEVICE_OWNER));
613         mUserManager.setUserRestrictionSources(
614                 UserManager.DISALLOW_REMOVE_USER,
615                 UserHandle.of(UserHandle.myUserId()),
616                 enforcingUsers
617         );
618 
619         boolean result = mFragment.canDeleteUser();
620 
621         assertThat(result).isFalse();
622     }
623 
setupSelectedUser()624     private void setupSelectedUser() {
625         mArguments.putInt("user_id", 1);
626         mUserInfo = new UserInfo(1, "Tom", null,
627                 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED,
628                 UserManager.USER_TYPE_FULL_SECONDARY);
629 
630         mUserManager.addProfile(mUserInfo);
631     }
632 
setupSelectedGuest()633     private void setupSelectedGuest() {
634         mArguments.putInt("user_id", 23);
635         mUserInfo = new UserInfo(23, "Guest", null,
636                 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_GUEST,
637                 UserManager.USER_TYPE_FULL_GUEST);
638 
639         mUserManager.addProfile(mUserInfo);
640     }
641 
setupSelectedRestrictedUser()642     private void setupSelectedRestrictedUser() {
643         mArguments.putInt("user_id", 21);
644         mUserInfo = new UserInfo(21, "Bob", null,
645                 UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_RESTRICTED,
646                 UserManager.USER_TYPE_FULL_RESTRICTED);
647 
648         mUserManager.addProfile(mUserInfo);
649     }
650 }
651