1 /* 2 * Copyright (C) 2017 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.applications.defaultapps; 18 19 import static com.google.common.truth.Truth.assertThat; 20 21 import static org.mockito.ArgumentMatchers.any; 22 import static org.mockito.Mockito.doNothing; 23 import static org.mockito.Mockito.doReturn; 24 import static org.mockito.Mockito.mock; 25 import static org.mockito.Mockito.spy; 26 import static org.mockito.Mockito.when; 27 import static org.robolectric.RuntimeEnvironment.application; 28 29 import android.app.AppOpsManager; 30 import android.content.Context; 31 import android.content.Intent; 32 import android.content.pm.PackageManager; 33 import android.content.pm.UserInfo; 34 import android.content.res.Resources; 35 import android.os.Bundle; 36 import android.os.UserHandle; 37 import android.os.UserManager; 38 39 import androidx.fragment.app.FragmentActivity; 40 import androidx.preference.PreferenceScreen; 41 42 import com.android.settings.testutils.FakeFeatureFactory; 43 import com.android.settings.testutils.shadow.ShadowSecureSettings; 44 import com.android.settingslib.applications.DefaultAppInfo; 45 46 import org.junit.Before; 47 import org.junit.Test; 48 import org.junit.runner.RunWith; 49 import org.mockito.Answers; 50 import org.mockito.Mock; 51 import org.mockito.MockitoAnnotations; 52 import org.robolectric.RobolectricTestRunner; 53 import org.robolectric.annotation.Config; 54 import org.robolectric.shadows.ShadowProcess; 55 import org.robolectric.util.ReflectionHelpers; 56 57 import java.util.Arrays; 58 59 @RunWith(RobolectricTestRunner.class) 60 @Config(shadows = ShadowSecureSettings.class) 61 public class DefaultAutofillPickerTest { 62 63 private static final String MAIN_APP_KEY = "main.foo.bar/foo.bar.Baz"; 64 private static final String MANAGED_APP_KEY = "managed.foo.bar/foo.bar.Baz"; 65 private static final int MANAGED_PROFILE_UID = 10; 66 private static final int MAIN_PROFILE_UID = 0; 67 68 @Mock(answer = Answers.RETURNS_DEEP_STUBS) 69 private FragmentActivity mActivity; 70 @Mock 71 private UserManager mUserManager; 72 @Mock 73 private AppOpsManager mAppOpsManager; 74 @Mock 75 private PackageManager mPackageManager; 76 @Mock 77 private PreferenceScreen mScreen; 78 79 private DefaultAutofillPicker mPicker; 80 81 @Before setUp()82 public void setUp() { 83 MockitoAnnotations.initMocks(this); 84 FakeFeatureFactory.setupForTest(); 85 86 Resources res = application.getResources(); 87 88 when(mActivity.getApplicationContext()).thenReturn(mActivity); 89 when(mActivity.getSystemService(Context.APP_OPS_SERVICE)).thenReturn(mAppOpsManager); 90 when(mActivity.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager); 91 when(mActivity.getTheme()).thenReturn(res.newTheme()); 92 when(mActivity.getResources()).thenReturn(res); 93 94 mPicker = spy(new DefaultAutofillPicker()); 95 96 doReturn(application).when(mPicker).getContext(); 97 doReturn(mActivity).when(mPicker).getActivity(); 98 doReturn(res).when(mPicker).getResources(); 99 doReturn(mScreen).when(mPicker).getPreferenceScreen(); 100 101 doNothing().when(mPicker).onCreatePreferences(any(), any()); 102 doNothing().when(mPicker).updateCandidates(); 103 104 ReflectionHelpers.setField(mPicker, "mPm", mPackageManager); 105 } 106 107 @Test setAndGetDefaultAppKey_shouldUpdateDefaultAutoFill()108 public void setAndGetDefaultAppKey_shouldUpdateDefaultAutoFill() { 109 mPicker.onAttach((Context) mActivity); 110 111 ReflectionHelpers.setField( 112 mPicker, "mUserId", MAIN_PROFILE_UID * UserHandle.PER_USER_RANGE); 113 assertThat(mPicker.setDefaultKey(MAIN_APP_KEY)).isTrue(); 114 ReflectionHelpers.setField( 115 mPicker, "mUserId", MANAGED_PROFILE_UID * UserHandle.PER_USER_RANGE); 116 assertThat(mPicker.setDefaultKey(MANAGED_APP_KEY)).isTrue(); 117 118 ReflectionHelpers.setField( 119 mPicker, "mUserId", MAIN_PROFILE_UID * UserHandle.PER_USER_RANGE); 120 assertThat(mPicker.getDefaultKey()).isEqualTo(MAIN_APP_KEY); 121 ReflectionHelpers.setField( 122 mPicker, "mUserId", MANAGED_PROFILE_UID * UserHandle.PER_USER_RANGE); 123 assertThat(mPicker.getDefaultKey()).isEqualTo(MANAGED_APP_KEY); 124 } 125 126 @Test getConfirmationMessage_shouldNotBeNull()127 public void getConfirmationMessage_shouldNotBeNull() { 128 mPicker.onAttach((Context) mActivity); 129 130 final DefaultAppInfo info = mock(DefaultAppInfo.class); 131 when(info.loadLabel()).thenReturn("test_app_name"); 132 assertThat(mPicker.getConfirmationMessage(info)).isNotNull(); 133 } 134 135 @Test mUserId_shouldDeriveUidFromManagedCaller()136 public void mUserId_shouldDeriveUidFromManagedCaller() { 137 setupUserManager(); 138 setupCaller(); 139 ShadowProcess.setUid(MANAGED_PROFILE_UID * UserHandle.PER_USER_RANGE); 140 141 mPicker.onAttach((Context) mActivity); 142 mPicker.onCreate(null); 143 144 assertUserId(MANAGED_PROFILE_UID); 145 } 146 147 @Test mUserId_shouldDeriveUidFromMainCaller()148 public void mUserId_shouldDeriveUidFromMainCaller() { 149 setupUserManager(); 150 setupCaller(); 151 ShadowProcess.setUid(MAIN_PROFILE_UID * UserHandle.PER_USER_RANGE); 152 153 mPicker.onAttach((Context) mActivity); 154 mPicker.onCreate(null); 155 156 assertUserId(MAIN_PROFILE_UID); 157 } 158 159 @Test mUserId_shouldDeriveUidFromManagedClick()160 public void mUserId_shouldDeriveUidFromManagedClick() { 161 setupUserManager(); 162 setupClick(/* forWork= */ true); 163 ShadowProcess.setUid(MAIN_PROFILE_UID * UserHandle.PER_USER_RANGE); 164 165 mPicker.onAttach((Context) mActivity); 166 mPicker.onCreate(null); 167 168 assertUserId(MANAGED_PROFILE_UID); 169 } 170 171 @Test mUserId_shouldDeriveUidFromMainClick()172 public void mUserId_shouldDeriveUidFromMainClick() { 173 setupUserManager(); 174 setupClick(/* forWork= */ false); 175 ShadowProcess.setUid(MAIN_PROFILE_UID * UserHandle.PER_USER_RANGE); 176 177 mPicker.onAttach((Context) mActivity); 178 mPicker.onCreate(null); 179 180 assertUserId(MAIN_PROFILE_UID); 181 } 182 setupUserManager()183 private void setupUserManager() { 184 UserHandle mainUserHandle = new UserHandle(MAIN_PROFILE_UID); 185 UserHandle managedUserHandle = new UserHandle(MANAGED_PROFILE_UID); 186 UserInfo managedUserInfo = new UserInfo( 187 MANAGED_PROFILE_UID, "managed", UserInfo.FLAG_MANAGED_PROFILE); 188 when(mUserManager.getUserProfiles()) 189 .thenReturn(Arrays.asList(mainUserHandle, managedUserHandle)); 190 when(mUserManager.getUserInfo(MANAGED_PROFILE_UID)) 191 .thenReturn(managedUserInfo); 192 when(mUserManager.getUserHandle()).thenReturn(MAIN_PROFILE_UID); 193 } 194 setupCaller()195 private void setupCaller() { 196 Intent intent = new Intent(); 197 intent.putExtra("package_name", "any package name"); 198 when(mActivity.getIntent()).thenReturn(intent); 199 } 200 setupClick(boolean forWork)201 private void setupClick(boolean forWork) { 202 Bundle bundle = new Bundle(); 203 bundle.putBoolean("for_work", forWork); 204 doReturn(bundle).when(mPicker).getArguments(); 205 } 206 assertUserId(int userId)207 private void assertUserId(int userId) { 208 assertThat((Integer) ReflectionHelpers.getField(mPicker, "mUserId")).isEqualTo(userId); 209 } 210 } 211