PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Improve multi user settings screen" into rvc-dev am: e26de87100 am: 7b58b02285 am: 6e771fdf55 am: 539843c31a

Browse Source 
Change-Id: I72dc5f0d5d0764903de89bbff745b5466090db78
This commit is contained in:
TreeHugger Robot
2020-05-08 03:45:47 +00:00
committed by Automerger Merge Worker
parent a16583dae5 539843c31a
commit 77573ddec7
16 changed files with 1469 additions and 523 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
tests/robotests/src/com/android/settings/testutils/shadow/ShadowUserManager.java
View File

@@ -18,6 +18,7 @@ package com.android.settings.testutils.shadow;
import android.annotation.UserIdInt;
import android.content.pm.UserInfo;
import android.os.Bundle;
import android.os.UserHandle;
import android.os.UserManager;
import android.os.UserManager.EnforcingUser;
@@ -43,13 +44,17 @@ public class ShadowUserManager extends org.robolectric.shadows.ShadowUserManager
private static boolean sIsSupportsMultipleUsers;
private final List<String> mRestrictions = new ArrayList<>();
private final List<String> mBaseRestrictions = new ArrayList<>();
private final List<String> mGuestRestrictions = new ArrayList<>();
private final Map<String, List<EnforcingUser>> mRestrictionSources = new HashMap<>();
private final List<UserInfo> mUserProfileInfos = new ArrayList<>();
private final Set<Integer> mManagedProfiles = new HashSet<>();
private boolean mIsQuietModeEnabled = false;
private int[] profileIdsForUser = new int[0];
private boolean mUserSwitchEnabled;
private @UserManager.UserSwitchabilityResult int mSwitchabilityStatus =
UserManager.SWITCHABILITY_STATUS_OK;
private final Map<Integer, Integer> mSameProfileGroupIds = Maps.newHashMap();
public void addProfile(UserInfo userInfo) {
@@ -82,11 +87,22 @@ public class ShadowUserManager extends org.robolectric.shadows.ShadowUserManager
@Implementation
protected boolean hasBaseUserRestriction(String restrictionKey, UserHandle userHandle) {
return mRestrictions.contains(restrictionKey);
return mBaseRestrictions.contains(restrictionKey);
}
public void addBaseUserRestriction(String restriction) {
mRestrictions.add(restriction);
mBaseRestrictions.add(restriction);
}
@Implementation
protected Bundle getDefaultGuestRestrictions() {
Bundle bundle = new Bundle();
mGuestRestrictions.forEach(restriction -> bundle.putBoolean(restriction, true));
return bundle;
}
public void addGuestUserRestriction(String restriction) {
mGuestRestrictions.add(restriction);
}
public static ShadowUserManager getShadow() {
@@ -166,4 +182,21 @@ public class ShadowUserManager extends org.robolectric.shadows.ShadowUserManager
public void setSupportsMultipleUsers(boolean supports) {
sIsSupportsMultipleUsers = supports;
}
@Implementation
protected UserInfo getUserInfo(@UserIdInt int userId) {
return mUserProfileInfos.stream()
.filter(userInfo -> userInfo.id == userId)
.findFirst()
.orElse(super.getUserInfo(userId));
}
@Implementation
protected @UserManager.UserSwitchabilityResult int getUserSwitchability() {
return mSwitchabilityStatus;
}
public void setSwitchabilityStatus(@UserManager.UserSwitchabilityResult int newStatus) {
mSwitchabilityStatus = newStatus;
}
}

467
tests/robotests/src/com/android/settings/users/UserDetailsSettingsTest.java Normal file
View File

@@ -0,0 +1,467 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.users;
import static android.os.UserManager.SWITCHABILITY_STATUS_OK;
import static android.os.UserManager.SWITCHABILITY_STATUS_USER_IN_CALL;
import static android.os.UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.UserInfo;
import android.os.Bundle;
import android.os.UserHandle;
import android.os.UserManager;
import android.telephony.TelephonyManager;
import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
import com.android.settings.R;
import com.android.settings.testutils.shadow.ShadowDevicePolicyManager;
import com.android.settings.testutils.shadow.ShadowUserManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.android.controller.ActivityController;
import org.robolectric.annotation.Config;
import org.robolectric.shadow.api.Shadow;
import org.robolectric.util.ReflectionHelpers;
import java.util.ArrayList;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = {
ShadowUserManager.class,
ShadowDevicePolicyManager.class
})
public class UserDetailsSettingsTest {
private static final String KEY_SWITCH_USER = "switch_user";
private static final String KEY_ENABLE_TELEPHONY = "enable_calling";
private static final String KEY_REMOVE_USER = "remove_user";
private static final int DIALOG_CONFIRM_REMOVE = 1;
@Mock
private TelephonyManager mTelephonyManager;
private ShadowUserManager mUserManager;
@Mock
private Preference mSwitchUserPref;
@Mock
private SwitchPreference mPhonePref;
@Mock
private Preference mRemoveUserPref;
private FragmentActivity mActivity;
private Context mContext;
private UserDetailsSettings mFragment;
private Bundle mArguments;
private UserInfo mUserInfo;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mActivity = spy(ActivityController.of(new FragmentActivity()).get());
mContext = spy(RuntimeEnvironment.application);
mFragment = spy(new UserDetailsSettings());
mArguments = new Bundle();
UserManager userManager = (UserManager) mContext.getSystemService(
Context.USER_SERVICE);
mUserManager = Shadow.extract(userManager);
doReturn(mTelephonyManager).when(mActivity).getSystemService(Context.TELEPHONY_SERVICE);
ReflectionHelpers.setField(mFragment, "mUserManager", userManager);
doReturn(mActivity).when(mFragment).getActivity();
doReturn(mContext).when(mFragment).getContext();
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
doReturn("").when(mActivity).getString(anyInt(), anyString());
doReturn(mSwitchUserPref).when(mFragment).findPreference(KEY_SWITCH_USER);
doReturn(mPhonePref).when(mFragment).findPreference(KEY_ENABLE_TELEPHONY);
doReturn(mRemoveUserPref).when(mFragment).findPreference(KEY_REMOVE_USER);
}
@After
public void tearDown() {
ShadowUserManager.reset();
}
@Test(expected = IllegalStateException.class)
public void initialize_nullArguments_shouldThrowException() {
mFragment.initialize(mActivity, null);
}
@Test(expected = IllegalStateException.class)
public void initialize_emptyArguments_shouldThrowException() {
mFragment.initialize(mActivity, new Bundle());
}
@Test
public void initialize_userSelected_shouldSetupSwitchPref() {
setupSelectedUser();
doReturn("Switch to " + mUserInfo.name)
.when(mActivity).getString(anyInt(), anyString());
mFragment.initialize(mActivity, mArguments);
verify(mActivity).getString(com.android.settingslib.R.string.user_switch_to_user,
mUserInfo.name);
verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name);
verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment);
verify(mFragment, never()).removePreference(KEY_SWITCH_USER);
}
@Test
public void initialize_guestSelected_shouldSetupSwitchPref() {
setupSelectedGuest();
doReturn("Switch to " + mUserInfo.name)
.when(mActivity).getString(anyInt(), anyString());
mFragment.initialize(mActivity, mArguments);
verify(mActivity).getString(com.android.settingslib.R.string.user_switch_to_user,
mUserInfo.name);
verify(mSwitchUserPref).setTitle("Switch to " + mUserInfo.name);
verify(mSwitchUserPref).setOnPreferenceClickListener(mFragment);
verify(mFragment, never()).removePreference(KEY_SWITCH_USER);
}
@Test
public void onResume_canSwitch_shouldEnableSwitchPref() {
mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.onAttach(mContext);
mFragment.onResume();
verify(mSwitchUserPref).setEnabled(true);
}
@Test
public void onResume_userInCall_shouldDisableSwitchPref() {
mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_IN_CALL);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.onAttach(mContext);
mFragment.onResume();
verify(mSwitchUserPref).setEnabled(false);
}
@Test
public void onResume_switchDisallowed_shouldDisableSwitchPref() {
mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.onAttach(mContext);
mFragment.onResume();
verify(mSwitchUserPref).setEnabled(false);
}
@Test
public void onResume_systemUserLocked_shouldDisableSwitchPref() {
mUserManager.setSwitchabilityStatus(UserManager.SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.onAttach(mContext);
mFragment.onResume();
verify(mSwitchUserPref).setEnabled(false);
}
@Test
public void initialize_adminWithTelephony_shouldShowPhonePreference() {
setupSelectedUser();
doReturn(true).when(mTelephonyManager).isVoiceCapable();
mUserManager.setIsAdminUser(true);
mFragment.initialize(mActivity, mArguments);
verify(mFragment, never()).removePreference(KEY_ENABLE_TELEPHONY);
verify(mPhonePref).setOnPreferenceChangeListener(mFragment);
}
@Test
public void initialize_adminNoTelephony_shouldNotShowPhonePreference() {
setupSelectedUser();
doReturn(false).when(mTelephonyManager).isVoiceCapable();
mUserManager.setIsAdminUser(true);
doReturn(null).when(mActivity).getSystemService(Context.TELEPHONY_SERVICE);
mFragment.initialize(mActivity, mArguments);
verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY);
}
@Test
public void initialize_nonAdminWithTelephony_shouldNotShowPhonePreference() {
setupSelectedUser();
doReturn(true).when(mTelephonyManager).isVoiceCapable();
mUserManager.setIsAdminUser(false);
mFragment.initialize(mActivity, mArguments);
verify(mFragment).removePreference(KEY_ENABLE_TELEPHONY);
}
@Test
public void initialize_adminSelectsSecondaryUser_shouldShowRemovePreference() {
setupSelectedUser();
mUserManager.setIsAdminUser(true);
mFragment.initialize(mActivity, mArguments);
verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment);
verify(mRemoveUserPref).setTitle(R.string.user_remove_user);
verify(mFragment, never()).removePreference(KEY_REMOVE_USER);
}
@Test
public void initialize_adminSelectsGuest_shouldShowRemovePreference() {
setupSelectedGuest();
mUserManager.setIsAdminUser(true);
mFragment.initialize(mActivity, mArguments);
verify(mRemoveUserPref).setOnPreferenceClickListener(mFragment);
verify(mRemoveUserPref).setTitle(R.string.user_exit_guest_title);
verify(mFragment, never()).removePreference(KEY_REMOVE_USER);
}
@Test
public void initialize_nonAdmin_shouldNotShowRemovePreference() {
setupSelectedUser();
mUserManager.setIsAdminUser(false);
mFragment.initialize(mActivity, mArguments);
verify(mFragment).removePreference(KEY_REMOVE_USER);
}
@Test
public void initialize_disallowRemoveUserRestriction_shouldNotShowRemovePreference() {
setupSelectedUser();
mUserManager.setIsAdminUser(true);
mUserManager.addBaseUserRestriction(UserManager.DISALLOW_REMOVE_USER);
mFragment.initialize(mActivity, mArguments);
verify(mFragment).removePreference(KEY_REMOVE_USER);
}
@Test
public void initialize_userHasCallRestriction_shouldSetPhoneSwitchUnChecked() {
setupSelectedUser();
mUserManager.setIsAdminUser(true);
mUserManager.setUserRestriction(mUserInfo.getUserHandle(),
UserManager.DISALLOW_OUTGOING_CALLS, true);
mFragment.initialize(mActivity, mArguments);
verify(mPhonePref).setChecked(false);
}
@Test
public void initialize_noCallRestriction_shouldSetPhoneSwitchChecked() {
setupSelectedUser();
mUserManager.setIsAdminUser(true);
mFragment.initialize(mActivity, mArguments);
verify(mPhonePref).setChecked(true);
}
@Test
public void initialize_guestSelected_noCallRestriction_shouldSetPhonePreference() {
setupSelectedGuest();
mUserManager.setIsAdminUser(true);
mFragment.initialize(mActivity, mArguments);
verify(mPhonePref).setTitle(R.string.user_enable_calling);
verify(mPhonePref).setChecked(true);
}
@Test
public void initialize_guestSelected_callRestriction_shouldSetPhonePreference() {
setupSelectedGuest();
mUserManager.setIsAdminUser(true);
mUserManager.addGuestUserRestriction(UserManager.DISALLOW_OUTGOING_CALLS);
mFragment.initialize(mActivity, mArguments);
verify(mPhonePref).setTitle(R.string.user_enable_calling);
verify(mPhonePref).setChecked(false);
}
@Test
public void onPreferenceClick_switchClicked_canSwitch_shouldSwitch() {
setupSelectedUser();
mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_OK);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.mRemoveUserPref = mRemoveUserPref;
mFragment.mUserInfo = mUserInfo;
mFragment.onPreferenceClick(mSwitchUserPref);
verify(mFragment).switchUser();
}
@Test
public void onPreferenceClick_switchClicked_canNotSwitch_doNothing() {
setupSelectedUser();
mUserManager.setSwitchabilityStatus(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.mRemoveUserPref = mRemoveUserPref;
mFragment.mUserInfo = mUserInfo;
mFragment.onPreferenceClick(mSwitchUserPref);
verify(mFragment, never()).switchUser();
}
@Test
public void onPreferenceClick_removeClicked_canDelete_shouldShowDialog() {
setupSelectedUser();
mFragment.mUserInfo = mUserInfo;
mUserManager.setIsAdminUser(true);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.mRemoveUserPref = mRemoveUserPref;
doNothing().when(mFragment).showDialog(anyInt());
mFragment.onPreferenceClick(mRemoveUserPref);
verify(mFragment).canDeleteUser();
verify(mFragment).showDialog(DIALOG_CONFIRM_REMOVE);
}
@Test
public void onPreferenceClick_removeClicked_canNotDelete_doNothing() {
setupSelectedUser();
mFragment.mUserInfo = mUserInfo;
mUserManager.setIsAdminUser(false);
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.mRemoveUserPref = mRemoveUserPref;
doNothing().when(mFragment).showDialog(anyInt());
mFragment.onPreferenceClick(mRemoveUserPref);
verify(mFragment).canDeleteUser();
verify(mFragment, never()).showDialog(DIALOG_CONFIRM_REMOVE);
}
@Test
public void onPreferenceClick_unknownPreferenceClicked_doNothing() {
setupSelectedUser();
mFragment.mUserInfo = mUserInfo;
mFragment.mSwitchUserPref = mSwitchUserPref;
mFragment.mRemoveUserPref = mRemoveUserPref;
mFragment.onPreferenceClick(mock(UserPreference.class));
verify(mFragment).onPreferenceClick(any());
verifyNoMoreInteractions(mFragment);
}
@Test
public void canDeleteUser_nonAdminUser_shouldReturnFalse() {
mUserManager.setIsAdminUser(false);
boolean result = mFragment.canDeleteUser();
assertThat(result).isFalse();
}
@Test
public void canDeleteUser_adminSelectsUser_noRestrictions_shouldReturnTrue() {
setupSelectedUser();
mUserManager.setIsAdminUser(true);
boolean result = mFragment.canDeleteUser();
assertThat(result).isTrue();
}
@Test
public void canDeleteUser_adminSelectsUser_hasRemoveRestriction_shouldReturnFalse() {
setupSelectedUser();
mUserManager.setIsAdminUser(true);
ComponentName componentName = new ComponentName("test", "test");
ShadowDevicePolicyManager.getShadow().setDeviceOwnerComponentOnAnyUser(componentName);
ShadowDevicePolicyManager.getShadow().setDeviceOwnerUserId(UserHandle.myUserId());
List<UserManager.EnforcingUser> enforcingUsers = new ArrayList<>();
enforcingUsers.add(new UserManager.EnforcingUser(UserHandle.myUserId(),
UserManager.RESTRICTION_SOURCE_DEVICE_OWNER));
mUserManager.setUserRestrictionSources(
UserManager.DISALLOW_REMOVE_USER,
UserHandle.of(UserHandle.myUserId()),
enforcingUsers
);
boolean result = mFragment.canDeleteUser();
assertThat(result).isFalse();
}
private void setupSelectedUser() {
mArguments.putInt("user_id", 1);
mUserInfo = new UserInfo(1, "Tom", null,
UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED,
UserManager.USER_TYPE_FULL_SECONDARY);
mUserManager.addProfile(mUserInfo);
}
private void setupSelectedGuest() {
mArguments.putInt("user_id", 23);
mUserInfo = new UserInfo(23, "Guest", null,
UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_GUEST,
UserManager.USER_TYPE_FULL_GUEST);
mUserManager.addProfile(mUserInfo);
}
}

24
tests/robotests/src/com/android/settings/users/UserPreferenceTest.java
View File

@@ -18,12 +18,8 @@ package com.android.settings.users;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.os.UserHandle;
import android.view.View;
import com.android.settingslib.RestrictedPreferenceHelper;
@@ -48,28 +44,12 @@ public class UserPreferenceTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mUserPreference = new UserPreference(mContext, null /* attrs */, UserHandle.USER_CURRENT,
null /* settingsListener */, null /* deleteListener */);
mUserPreference = new UserPreference(mContext, null /* attrs */, UserHandle.USER_CURRENT);
ReflectionHelpers.setField(mUserPreference, "mHelper", mRestrictedPreferenceHelper);
}
@Test
public void testShouldHideSecondTarget_noListener_shouldHide() {
public void testShouldHideSecondTarget_shouldHide() {
assertThat(mUserPreference.shouldHideSecondTarget()).isTrue();
}
@Test
public void testShouldHideSecondTarget_disabledByAdmin_shouldHide() {
when(mRestrictedPreferenceHelper.isDisabledByAdmin()).thenReturn(true);
assertThat(mUserPreference.shouldHideSecondTarget()).isTrue();
}
@Test
public void testShouldHideSecondTarget_hasSettingListener_shouldNotHide() {
ReflectionHelpers.setField(mUserPreference, "mSettingsClickListener",
mock(View.OnClickListener.class));
assertThat(mUserPreference.shouldHideSecondTarget()).isFalse();
}
}

607
tests/robotests/src/com/android/settings/users/UserSettingsTest.java
View File

@@ -16,9 +16,14 @@
package com.android.settings.users;
import static android.os.UserManager.SWITCHABILITY_STATUS_OK;
import static android.os.UserManager.SWITCHABILITY_STATUS_USER_IN_CALL;
import static android.os.UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.notNull;
@@ -26,12 +31,14 @@ import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.ComponentName;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.pm.UserInfo;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.os.UserHandle;
import android.os.UserManager;
@@ -42,14 +49,13 @@ import android.view.MenuInflater;
import android.view.MenuItem;
import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceGroup;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
import com.android.settings.testutils.shadow.ShadowDevicePolicyManager;
import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.RestrictedPreference;
import org.junit.After;
@@ -57,6 +63,7 @@ import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.AdditionalMatchers;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
@@ -65,6 +72,7 @@ import org.robolectric.android.controller.ActivityController;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@@ -73,7 +81,18 @@ import java.util.List;
public class UserSettingsTest {
private static final String KEY_USER_GUEST = "user_guest";
private int mProvisioned;
private static final int ACTIVE_USER_ID = 0;
private static final int INACTIVE_ADMIN_USER_ID = 1;
private static final int INACTIVE_SECONDARY_USER_ID = 14;
private static final int INACTIVE_RESTRICTED_USER_ID = 21;
private static final int INACTIVE_GUEST_USER_ID = 23;
private static final int MANAGED_USER_ID = 11;
private static final String ADMIN_USER_NAME = "Owner";
private static final String SECONDARY_USER_NAME = "Tom";
private static final String RESTRICTED_USER_NAME = "Bob";
private static final String GUEST_USER_NAME = "Guest";
private static final String MANAGED_USER_NAME = "Work profile";
private int mProvisionedBackupValue;
@Mock
private Drawable mDefaultIconDrawable;
@@ -82,6 +101,10 @@ public class UserSettingsTest {
@Mock
private UserPreference mMePreference;
@Mock
private RestrictedPreference mAddUserPreference;
@Mock
private RestrictedPreference mAddGuestPreference;
@Mock
private UserManager mUserManager;
private FragmentActivity mActivity;
@@ -95,6 +118,7 @@ public class UserSettingsTest {
mActivity = spy(ActivityController.of(new FragmentActivity()).get());
mContext = spy(RuntimeEnvironment.application);
mUserCapabilities = UserCapabilities.create(mContext);
mUserCapabilities.mUserSwitcherEnabled = true;
mFragment = spy(new UserSettings());
ReflectionHelpers.setField(mFragment, "mAddUserWhenLockedPreferenceController",
@@ -105,100 +129,41 @@ public class UserSettingsTest {
ReflectionHelpers.setField(mFragment, "mUserCaps", mUserCapabilities);
ReflectionHelpers.setField(mFragment, "mDefaultIconDrawable", mDefaultIconDrawable);
ReflectionHelpers.setField(mFragment, "mAddingUser", false);
mFragment.mMePreference = mMePreference;
when((Object) mActivity.getSystemService(UserManager.class)).thenReturn(mUserManager);
doReturn(mUserManager).when(mActivity).getSystemService(UserManager.class);
doReturn(mActivity).when(mFragment).getActivity();
doReturn(mContext).when(mFragment).getContext();
doReturn(mMockPreferenceManager).when(mFragment).getPreferenceManager();
doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
mProvisioned = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 0);
final SharedPreferences prefs = mock(SharedPreferences .class);
when(mMockPreferenceManager.getSharedPreferences()).thenReturn(prefs);
when(mMockPreferenceManager.getContext()).thenReturn(mContext);
mProvisionedBackupValue = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 0);
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 1); //default state
final SharedPreferences prefs = mock(SharedPreferences.class);
doReturn(prefs).when(mMockPreferenceManager).getSharedPreferences();
doReturn(mContext).when(mMockPreferenceManager).getContext();
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
mFragment.mMePreference = mMePreference;
mFragment.mAddUser = mAddUserPreference;
mFragment.mAddGuest = mAddGuestPreference;
mFragment.mUserListCategory = mock(PreferenceCategory.class);
}
@After
public void tearDown() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, mProvisioned);
Settings.Global.DEVICE_PROVISIONED, mProvisionedBackupValue);
}
@Test
public void testAssignDefaultPhoto_ContextNull_ReturnFalseAndNotCrash() {
// Should not crash here
assertThat(UserSettings.assignDefaultPhoto(null, 0)).isFalse();
}
@Test
public void updateUserList_cannotSwitchUser_shouldNotBeSelectableForGuest() {
final RestrictedPreference addUser = spy(new RestrictedPreference(mContext));
final PreferenceGroup userListCategory = spy(new PreferenceCategory(mContext));
mUserCapabilities.mIsGuest = false;
mUserCapabilities.mCanAddGuest = true;
mUserCapabilities.mDisallowAddUser = false;
mUserCapabilities.mDisallowSwitchUser = false;
mUserCapabilities.mUserSwitcherEnabled = true;
mFragment.mUserListCategory = userListCategory;
mFragment.mAddUser = addUser;
when(mUserManager.canSwitchUsers()).thenReturn(false);
doReturn(mMockPreferenceManager).when(mFragment).getPreferenceManager();
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
doReturn(mMockPreferenceManager).when(userListCategory).getPreferenceManager();
mFragment.updateUserList();
final Preference guest = userListCategory.findPreference(KEY_USER_GUEST);
assertThat(guest.isSelectable()).isFalse();
}
@Test
public void updateUserList_cannotSwitchUser_shouldDisableAddUser() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 1);
final RestrictedPreference addUser = spy(new RestrictedPreference(mContext));
final PreferenceGroup userListCategory = spy(new PreferenceCategory(mContext));
mUserCapabilities.mCanAddUser = true;
mUserCapabilities.mDisallowAddUser = false;
mUserCapabilities.mUserSwitcherEnabled = true;
mFragment.mUserListCategory = userListCategory;
mFragment.mAddUser = addUser;
when(mUserManager.canSwitchUsers()).thenReturn(false);
when(mUserManager.canAddMoreUsers()).thenReturn(true);
doReturn(mMockPreferenceManager).when(mFragment).getPreferenceManager();
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
doReturn(mMockPreferenceManager).when(userListCategory).getPreferenceManager();
mFragment.updateUserList();
assertThat(addUser.isEnabled()).isFalse();
}
@Test
public void updateUserList_cannotAddUserButCanSwitchUser_shouldNotShowAddUser() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 1);
final RestrictedPreference addUser = mock(RestrictedPreference.class);
mUserCapabilities.mCanAddUser = false;
mUserCapabilities.mDisallowAddUser = true;
mUserCapabilities.mUserSwitcherEnabled = true;
mFragment.mUserListCategory = mock(PreferenceCategory.class);
mFragment.mAddUser = addUser;
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
mFragment.updateUserList();
verify(addUser, never()).setVisible(true);
assertThat(UserSettings.assignDefaultPhoto(null, ACTIVE_USER_ID)).isFalse();
}
@Test
@@ -218,7 +183,7 @@ public class UserSettingsTest {
ShadowDevicePolicyManager.getShadow().setDeviceOwnerComponentOnAnyUser(
new ComponentName("test", "test"));
doReturn(true).when(mUserManager).canSwitchUsers();
doReturn(SWITCHABILITY_STATUS_OK).when(mUserManager).getUserSwitchability();
mUserCapabilities.mIsAdmin = false;
Menu menu = mock(Menu.class);
@@ -243,7 +208,7 @@ public class UserSettingsTest {
@Test
public void withoutDisallowRemoveUser_ShouldNotDisableRemoveUser() {
// Arrange
doReturn(true).when(mUserManager).canSwitchUsers();
doReturn(SWITCHABILITY_STATUS_OK).when(mUserManager).getUserSwitchability();
mUserCapabilities.mIsAdmin = false;
Menu menu = mock(Menu.class);
@@ -266,44 +231,458 @@ public class UserSettingsTest {
@Test
public void updateUserList_canAddUserAndSwitchUser_shouldShowAddUser() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 1);
final RestrictedPreference addUser = mock(RestrictedPreference.class);
mUserCapabilities.mCanAddUser = true;
mUserCapabilities.mDisallowAddUser = false;
mUserCapabilities.mUserSwitcherEnabled = true;
mFragment.mAddUser = addUser;
mFragment.mUserListCategory = mock(PreferenceCategory.class);
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
doReturn("Test summary").when(mFragment).getString(anyInt(), anyInt());
doReturn(true).when(mUserManager).canAddMoreUsers();
doReturn(true).when(mAddUserPreference).isEnabled();
doReturn(SWITCHABILITY_STATUS_OK).when(mUserManager).getUserSwitchability();
mFragment.updateUserList();
verify(addUser).setVisible(true);
verify(mAddUserPreference).setVisible(true);
verify(mAddUserPreference).setSummary(null);
verify(mAddUserPreference).setEnabled(true);
verify(mAddUserPreference).setDisabledByAdmin(null);
verify(mAddUserPreference).setSelectable(true);
}
@Test
public void updateUserList_addUserDisallowedByAdmin_shouldShowAddUserDisabled() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 1);
final RestrictedPreference addUser = mock(RestrictedPreference.class);
mUserCapabilities.mCanAddUser = false;
mUserCapabilities.mDisallowAddUser = true;
mUserCapabilities.mDisallowAddUserSetByAdmin = true;
mUserCapabilities.mUserSwitcherEnabled = true;
mFragment.mUserListCategory = mock(PreferenceCategory.class);
mFragment.mAddUser = addUser;
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
public void updateUserList_canAddGuestAndSwitchUser_shouldShowAddGuest() {
mUserCapabilities.mCanAddGuest = true;
doReturn(true).when(mUserManager).canAddMoreUsers();
doReturn(SWITCHABILITY_STATUS_OK).when(mUserManager).getUserSwitchability();
mFragment.updateUserList();
verify(addUser).setVisible(true);
assertThat(addUser.isEnabled()).isFalse();
verify(mAddGuestPreference).setVisible(true);
verify(mAddGuestPreference).setEnabled(true);
verify(mAddGuestPreference).setIcon(any(Drawable.class));
verify(mAddGuestPreference).setSelectable(true);
}
@Test
public void updateUserList_cannotSwitchUser_shouldDisableAddUser() {
mUserCapabilities.mCanAddUser = true;
doReturn(true).when(mUserManager).canAddMoreUsers();
doReturn(true).when(mAddUserPreference).isEnabled();
doReturn(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED)
.when(mUserManager).getUserSwitchability();
mFragment.updateUserList();
verify(mAddUserPreference).setVisible(true);
verify(mAddUserPreference).setSummary(null);
verify(mAddUserPreference).setEnabled(false);
verify(mAddUserPreference).setSelectable(true);
}
@Test
public void updateUserList_canNotAddMoreUsers_shouldDisableAddUserWithSummary() {
mUserCapabilities.mCanAddUser = true;
doReturn(false).when(mUserManager).canAddMoreUsers();
doReturn(false).when(mAddUserPreference).isEnabled();
doReturn(SWITCHABILITY_STATUS_OK).when(mUserManager).getUserSwitchability();
doReturn(4).when(mFragment).getRealUsersCount();
mFragment.updateUserList();
verify(mAddUserPreference).setVisible(true);
verify(mAddUserPreference).setSummary("You can add up to 4 users");
verify(mAddUserPreference).setEnabled(false);
verify(mAddUserPreference).setSelectable(true);
}
@Test
public void updateUserList_cannotSwitchUser_shouldDisableAddGuest() {
mUserCapabilities.mCanAddGuest = true;
doReturn(true).when(mUserManager).canAddMoreUsers();
doReturn(SWITCHABILITY_STATUS_USER_IN_CALL).when(mUserManager).getUserSwitchability();
mFragment.updateUserList();
verify(mAddGuestPreference).setVisible(true);
verify(mAddGuestPreference).setEnabled(false);
verify(mAddGuestPreference).setIcon(any(Drawable.class));
verify(mAddGuestPreference).setSelectable(true);
}
@Test
public void updateUserList_addUserDisallowedByAdmin_shouldShowDisabledAddUser() {
RestrictedLockUtils.EnforcedAdmin enforcedAdmin = mock(
RestrictedLockUtils.EnforcedAdmin.class);
mUserCapabilities.mEnforcedAdmin = enforcedAdmin;
mUserCapabilities.mCanAddUser = false;
mUserCapabilities.mDisallowAddUser = true;
mUserCapabilities.mDisallowAddUserSetByAdmin = true;
doReturn(true).when(mAddUserPreference).isEnabled();
mFragment.updateUserList();
verify(mAddUserPreference).setVisible(true);
ArgumentCaptor<RestrictedLockUtils.EnforcedAdmin> captor = ArgumentCaptor.forClass(
RestrictedLockUtils.EnforcedAdmin.class);
verify(mAddUserPreference).setDisabledByAdmin(captor.capture());
assertThat(captor.getValue()).isEqualTo(enforcedAdmin);
}
@Test
public void updateUserList_cannotAddUserButCanSwitchUser_shouldNotShowAddUser() {
mUserCapabilities.mCanAddUser = false;
mFragment.updateUserList();
verify(mAddUserPreference).setVisible(false);
}
@Test
public void updateUserList_canNotAddGuest_shouldNotShowAddGuest() {
mUserCapabilities.mCanAddGuest = false;
mFragment.updateUserList();
verify(mAddGuestPreference).setVisible(false);
}
@Test
public void updateUserList_notProvisionedDevice_shouldNotShowAddUser() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 0);
mUserCapabilities.mCanAddUser = true;
mFragment.updateUserList();
verify(mAddUserPreference).setVisible(false);
}
@Test
public void updateUserList_notProvisionedDevice_shouldNotShowAddGuest() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEVICE_PROVISIONED, 0);
mUserCapabilities.mCanAddGuest = true;
mFragment.updateUserList();
verify(mAddGuestPreference).setVisible(false);
}
@Test
public void updateUserList_userSwitcherDisabled_shouldNotShowAddUser() {
mUserCapabilities.mCanAddUser = true;
mUserCapabilities.mUserSwitcherEnabled = false;
mFragment.updateUserList();
verify(mAddUserPreference).setVisible(false);
}
@Test
public void updateUserList_userSwitcherDisabled_shouldNotShowAddGuest() {
mUserCapabilities.mCanAddGuest = true;
mUserCapabilities.mUserSwitcherEnabled = false;
mFragment.updateUserList();
verify(mAddGuestPreference).setVisible(false);
}
@Test
public void updateUserList_shouldAddAdminUserPreference() {
givenUsers(getAdminUser(true));
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory).addPreference(captor.capture());
UserPreference adminPref = captor.getValue();
assertThat(adminPref).isSameAs(mMePreference);
}
@Test
public void updateUserList_existingGuest_shouldAddGuestUserPreference() {
givenUsers(getAdminUser(true), getGuest(false));
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory, times(2))
.addPreference(captor.capture());
UserPreference guestPref = captor.getAllValues().get(1);
assertThat(guestPref.getUserId()).isEqualTo(INACTIVE_GUEST_USER_ID);
assertThat(guestPref.getTitle()).isEqualTo("Guest");
assertThat(guestPref.getIcon()).isNotNull();
assertThat(guestPref.getKey()).isEqualTo(KEY_USER_GUEST);
assertThat(guestPref.isEnabled()).isEqualTo(true);
assertThat(guestPref.isSelectable()).isEqualTo(true);
assertThat(guestPref.getOnPreferenceClickListener()).isSameAs(mFragment);
}
@Test
public void updateUserList_existingSecondaryUser_shouldAddSecondaryUserPreference() {
givenUsers(getAdminUser(true), getSecondaryUser(false));
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory, times(2))
.addPreference(captor.capture());
UserPreference userPref = captor.getAllValues().get(1);
assertThat(userPref.getUserId()).isEqualTo(INACTIVE_SECONDARY_USER_ID);
assertThat(userPref.getTitle()).isEqualTo(SECONDARY_USER_NAME);
assertThat(userPref.getIcon()).isNotNull();
assertThat(userPref.getKey()).isEqualTo("id=" + INACTIVE_SECONDARY_USER_ID);
assertThat(userPref.isEnabled()).isEqualTo(true);
assertThat(userPref.isSelectable()).isEqualTo(true);
assertThat(userPref.getOnPreferenceClickListener()).isSameAs(mFragment);
}
@Test
public void updateUserList_existingRestrictedUser_shouldAddRestrictedUserPreference() {
givenUsers(getAdminUser(true), getRestrictedUser(false));
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory, times(2))
.addPreference(captor.capture());
UserPreference userPref = captor.getAllValues().get(1);
assertThat(userPref.getUserId()).isEqualTo(INACTIVE_RESTRICTED_USER_ID);
assertThat(userPref.getTitle()).isEqualTo(RESTRICTED_USER_NAME);
assertThat(userPref.getIcon()).isNotNull();
assertThat(userPref.getKey()).isEqualTo("id=" + INACTIVE_RESTRICTED_USER_ID);
assertThat(userPref.getSummary()).isEqualTo("Restricted profile");
assertThat(userPref.isEnabled()).isEqualTo(true);
assertThat(userPref.isSelectable()).isEqualTo(true);
assertThat(userPref.getOnPreferenceClickListener()).isSameAs(mFragment);
}
@Test
public void updateUserList_existingManagedUser_shouldNotAddUserPreference() {
givenUsers(getAdminUser(true), getManagedUser());
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory).addPreference(captor.capture());
List<UserPreference> userPreferences = captor.getAllValues();
assertThat(userPreferences.size()).isEqualTo(1);
assertThat(userPreferences.get(0).getUserId()).isEqualTo(ACTIVE_USER_ID);
}
@Test
public void updateUserList_uninitializedRestrictedUser_shouldAddUserPreference() {
UserInfo restrictedUser = getRestrictedUser(false);
removeFlag(restrictedUser, UserInfo.FLAG_INITIALIZED);
givenUsers(getAdminUser(true), restrictedUser);
doReturn(SWITCHABILITY_STATUS_OK).when(mUserManager).getUserSwitchability();
mUserCapabilities.mDisallowSwitchUser = false;
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory, times(2))
.addPreference(captor.capture());
UserPreference userPref = captor.getAllValues().get(1);
assertThat(userPref.getUserId()).isEqualTo(INACTIVE_RESTRICTED_USER_ID);
assertThat(userPref.getTitle()).isEqualTo(RESTRICTED_USER_NAME);
assertThat(userPref.getIcon()).isNotNull();
assertThat(userPref.getKey()).isEqualTo("id=" + INACTIVE_RESTRICTED_USER_ID);
assertThat(userPref.getSummary()).isEqualTo("Not set up - Restricted profile");
assertThat(userPref.isEnabled()).isEqualTo(true);
assertThat(userPref.isSelectable()).isEqualTo(true);
assertThat(userPref.getOnPreferenceClickListener()).isSameAs(mFragment);
}
@Test
public void updateUserList_uninitializedUserAndCanNotSwitchUser_shouldDisablePref() {
UserInfo uninitializedUser = getSecondaryUser(false);
removeFlag(uninitializedUser, UserInfo.FLAG_INITIALIZED);
givenUsers(getAdminUser(true), uninitializedUser);
doReturn(SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED)
.when(mUserManager).getUserSwitchability();
mUserCapabilities.mDisallowSwitchUser = false;
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory, times(2))
.addPreference(captor.capture());
UserPreference userPref = captor.getAllValues().get(1);
assertThat(userPref.getUserId()).isEqualTo(INACTIVE_SECONDARY_USER_ID);
assertThat(userPref.getTitle()).isEqualTo(SECONDARY_USER_NAME);
assertThat(userPref.getIcon()).isNotNull();
assertThat(userPref.getKey()).isEqualTo("id=" + INACTIVE_SECONDARY_USER_ID);
assertThat(userPref.getSummary()).isEqualTo("Not set up");
assertThat(userPref.isEnabled()).isEqualTo(false);
assertThat(userPref.isSelectable()).isEqualTo(true);
assertThat(userPref.getOnPreferenceClickListener()).isSameAs(mFragment);
}
@Test
public void updateUserList_guestWithoutInitializedFlag_shouldNotSetSummary() {
UserInfo guest = getGuest(false);
removeFlag(guest, UserInfo.FLAG_INITIALIZED);
givenUsers(getAdminUser(true), guest);
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory, times(2))
.addPreference(captor.capture());
UserPreference userPref = captor.getAllValues().get(1);
assertThat(userPref.getUserId()).isEqualTo(INACTIVE_GUEST_USER_ID);
assertThat(userPref.getSummary()).isNull();
}
@Test
public void updateUserList_activeUserWithoutInitializedFlag_shouldNotSetSummary() {
UserInfo activeUser = getSecondaryUser(true);
removeFlag(activeUser, UserInfo.FLAG_INITIALIZED);
givenUsers(activeUser);
mFragment.updateUserList();
ArgumentCaptor<UserPreference> captor = ArgumentCaptor.forClass(UserPreference.class);
verify(mFragment.mUserListCategory).addPreference(captor.capture());
UserPreference userPref = captor.getValue();
assertThat(userPref.getUserId()).isEqualTo(ACTIVE_USER_ID);
assertThat(userPref.getSummary()).isNull();
}
@Test
public void updateUserList_guestIsAlreadyCreated_shouldNotShowAddGuest() {
givenUsers(getAdminUser(true), getGuest(true));
mUserCapabilities.mCanAddGuest = true;
mFragment.updateUserList();
verify(mAddGuestPreference).setVisible(false);
}
@Test
public void updateUserList_userIconLoaded_shouldNotLoadIcon() {
UserInfo currentUser = getAdminUser(true);
currentUser.iconPath = "/data/system/users/0/photo.png";
givenUsers(currentUser);
mFragment.mUserIcons.put(ACTIVE_USER_ID,
Bitmap.createBitmap(100, 200, Bitmap.Config.ARGB_8888));
mFragment.updateUserList();
verify(mUserManager, never()).getUserIcon(anyInt());
// updateUserList should be called only once
verify(mUserManager).getUsers(true);
}
@Test
public void updateUserList_userIconMissing_shouldLoadIcon() {
UserInfo currentUser = getAdminUser(true);
currentUser.iconPath = "/data/system/users/0/photo.png";
givenUsers(currentUser);
// create a non-empty sparsearray
mFragment.mUserIcons.put(5, Bitmap.createBitmap(100, 200, Bitmap.Config.ARGB_8888));
Bitmap userIcon = Bitmap.createBitmap(100, 200, Bitmap.Config.ARGB_8888);
doReturn(userIcon).when(mUserManager).getUserIcon(ACTIVE_USER_ID);
mFragment.updateUserList();
verify(mUserManager).getUserIcon(ACTIVE_USER_ID);
// updateUserList should be called another time after loading the icons
verify(mUserManager, times(2)).getUsers(true);
}
@Test
public void getRealUsersCount_onlyAdmin_shouldCount() {
givenUsers(getAdminUser(true));
int result = mFragment.getRealUsersCount();
assertThat(result).isEqualTo(1);
verify(mUserManager).getUsers();
}
@Test
public void getRealUsersCount_secondaryUser_shouldCount() {
givenUsers(getAdminUser(true), getSecondaryUser(false));
int result = mFragment.getRealUsersCount();
assertThat(result).isEqualTo(2);
verify(mUserManager).getUsers();
}
@Test
public void getRealUsersCount_restrictedUser_shouldCount() {
givenUsers(getAdminUser(true), getSecondaryUser(false));
int result = mFragment.getRealUsersCount();
assertThat(result).isEqualTo(2);
verify(mUserManager).getUsers();
}
@Test
public void getRealUsersCount_guest_shouldNotCount() {
givenUsers(getAdminUser(true), getGuest(false));
int result = mFragment.getRealUsersCount();
assertThat(result).isEqualTo(1);
verify(mUserManager).getUsers();
}
@Test
public void getRealUsersCount_managedUser_shouldNotCount() {
givenUsers(getAdminUser(true), getManagedUser());
int result = mFragment.getRealUsersCount();
assertThat(result).isEqualTo(1);
verify(mUserManager).getUsers();
}
private void givenUsers(UserInfo... userInfo) {
List<UserInfo> users = Arrays.asList(userInfo);
doReturn(users).when(mUserManager).getUsers();
doReturn(users).when(mUserManager).getUsers(anyBoolean());
}
private static void removeFlag(UserInfo userInfo, int flag) {
userInfo.flags &= ~flag;
}
private static UserInfo getAdminUser(boolean active) {
return new UserInfo(active ? ACTIVE_USER_ID : INACTIVE_ADMIN_USER_ID, ADMIN_USER_NAME,
null,
UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_ADMIN,
UserManager.USER_TYPE_FULL_SYSTEM);
}
private static UserInfo getSecondaryUser(boolean active) {
return new UserInfo(active ? ACTIVE_USER_ID : INACTIVE_SECONDARY_USER_ID,
SECONDARY_USER_NAME, null,
UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED,
UserManager.USER_TYPE_FULL_SECONDARY);
}
private static UserInfo getRestrictedUser(boolean active) {
return new UserInfo(active ? ACTIVE_USER_ID : INACTIVE_RESTRICTED_USER_ID,
RESTRICTED_USER_NAME, null,
UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_RESTRICTED,
UserManager.USER_TYPE_FULL_RESTRICTED);
}
private static UserInfo getManagedUser() {
return new UserInfo(MANAGED_USER_ID,
MANAGED_USER_NAME, null,
UserInfo.FLAG_PROFILE | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_MANAGED_PROFILE,
UserManager.USER_TYPE_PROFILE_MANAGED);
}
private static UserInfo getGuest(boolean active) {
return new UserInfo(active ? ACTIVE_USER_ID : INACTIVE_GUEST_USER_ID, GUEST_USER_NAME,
null,
UserInfo.FLAG_FULL | UserInfo.FLAG_INITIALIZED | UserInfo.FLAG_GUEST,
UserManager.USER_TYPE_FULL_GUEST);
}
}