tests/robotests/src/com/android/settings/applications/appinfo/AppInfoDashboardFragmentTest.java

   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.appinfo;
  18
  19 import static com.google.common.truth.Truth.assertThat;
  20
  21 import static org.mockito.ArgumentMatchers.nullable;
  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.never;
  26 import static org.mockito.Mockito.spy;
  27 import static org.mockito.Mockito.verify;
  28 import static org.mockito.Mockito.when;
  29
  30 import android.content.Context;
  31 import android.content.Intent;
  32 import android.content.pm.ApplicationInfo;
  33 import android.content.pm.PackageInfo;
  34 import android.content.pm.PackageManager;
  35 import android.content.pm.UserInfo;
  36 import android.os.UserManager;
  37
  38 import com.android.settings.SettingsActivity;
  39 import com.android.settings.TestConfig;
  40 import com.android.settings.testutils.SettingsRobolectricTestRunner;
  41 import com.android.settings.wrapper.DevicePolicyManagerWrapper;
  42 import com.android.settingslib.applications.AppUtils;
  43 import com.android.settingslib.applications.ApplicationsState.AppEntry;
  44 import com.android.settingslib.applications.instantapps.InstantAppDataProvider;
  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.RuntimeEnvironment;
  53 import org.robolectric.annotation.Config;
  54 import org.robolectric.util.ReflectionHelpers;
  55
  56 import java.util.ArrayList;
  57 import java.util.List;
  58
  59 @RunWith(SettingsRobolectricTestRunner.class)
  60 @Config(
  61     manifest = TestConfig.MANIFEST_PATH,
  62     sdk = TestConfig.SDK_VERSION
  63 )
  64 public final class AppInfoDashboardFragmentTest {
  65
  66     private static final String PACKAGE_NAME = "test_package_name";
  67
  68     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
  69     private UserManager mUserManager;
  70     @Mock
  71     private SettingsActivity mActivity;
  72     @Mock
  73     private DevicePolicyManagerWrapper mDevicePolicyManager;
  74     @Mock
  75     private PackageManager mPackageManager;
  76
  77     private AppInfoDashboardFragment mFragment;
  78     private Context mShadowContext;
  79
  80
  81     @Before
  82     public void setUp() {
  83         MockitoAnnotations.initMocks(this);
  84         mShadowContext = RuntimeEnvironment.application;
  85         mFragment = spy(new AppInfoDashboardFragment());
  86         doReturn(mActivity).when(mFragment).getActivity();
  87         doReturn(mShadowContext).when(mFragment).getContext();
  88         doReturn(mPackageManager).when(mActivity).getPackageManager();
  89
  90         // Default to not considering any apps to be instant (individual tests can override this).
  91         ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
  92                 (InstantAppDataProvider) (i -> false));
  93     }
  94
  95     @Test
  96     public void shouldShowUninstallForAll_installForOneOtherUserOnly_shouldReturnTrue() {
  97         when(mDevicePolicyManager.packageHasActiveAdmins(nullable(String.class))).thenReturn(false);
  98         when(mUserManager.getUsers().size()).thenReturn(2);
  99         ReflectionHelpers.setField(mFragment, "mDpm", mDevicePolicyManager);
 100         ReflectionHelpers.setField(mFragment, "mUserManager", mUserManager);
 101         final ApplicationInfo info = new ApplicationInfo();
 102         info.enabled = true;
 103         final AppEntry appEntry = mock(AppEntry.class);
 104         appEntry.info = info;
 105         final PackageInfo packageInfo = mock(PackageInfo.class);
 106         ReflectionHelpers.setField(mFragment, "mPackageInfo", packageInfo);
 107
 108         assertThat(mFragment.shouldShowUninstallForAll(appEntry)).isTrue();
 109     }
 110
 111     @Test
 112     public void shouldShowUninstallForAll_installForSelfOnly_shouldReturnFalse() {
 113         when(mDevicePolicyManager.packageHasActiveAdmins(nullable(String.class))).thenReturn(false);
 114         when(mUserManager.getUsers().size()).thenReturn(2);
 115         ReflectionHelpers.setField(mFragment, "mDpm", mDevicePolicyManager);
 116         ReflectionHelpers.setField(mFragment, "mUserManager", mUserManager);
 117         final ApplicationInfo info = new ApplicationInfo();
 118         info.flags = ApplicationInfo.FLAG_INSTALLED;
 119         info.enabled = true;
 120         final AppEntry appEntry = mock(AppEntry.class);
 121         appEntry.info = info;
 122         final PackageInfo packageInfo = mock(PackageInfo.class);
 123         ReflectionHelpers.setField(mFragment, "mPackageInfo", packageInfo);
 124
 125         assertThat(mFragment.shouldShowUninstallForAll(appEntry)).isFalse();
 126     }
 127
 128     @Test
 129     public void launchFragment_hasNoPackageInfo_shouldFinish() {
 130         ReflectionHelpers.setField(mFragment, "mPackageInfo", null);
 131
 132         assertThat(mFragment.ensurePackageInfoAvailable(mActivity)).isFalse();
 133         verify(mActivity).finishAndRemoveTask();
 134     }
 135
 136     @Test
 137     public void launchFragment_hasPackageInfo_shouldReturnTrue() {
 138         final PackageInfo packageInfo = mock(PackageInfo.class);
 139         ReflectionHelpers.setField(mFragment, "mPackageInfo", packageInfo);
 140
 141         assertThat(mFragment.ensurePackageInfoAvailable(mActivity)).isTrue();
 142         verify(mActivity, never()).finishAndRemoveTask();
 143     }
 144
 145     @Test
 146     public void packageSizeChange_isOtherPackage_shouldNotRefreshUi() {
 147         ReflectionHelpers.setField(mFragment, "mPackageName", PACKAGE_NAME);
 148         mFragment.onPackageSizeChanged("Not_" + PACKAGE_NAME);
 149
 150         verify(mFragment, never()).refreshUi();
 151     }
 152
 153     @Test
 154     public void packageSizeChange_isOwnPackage_shouldRefreshUi() {
 155         doReturn(Boolean.TRUE).when(mFragment).refreshUi();
 156         ReflectionHelpers.setField(mFragment, "mPackageName", PACKAGE_NAME);
 157
 158         mFragment.onPackageSizeChanged(PACKAGE_NAME);
 159
 160         verify(mFragment).refreshUi();
 161     }
 162
 163     // Tests that we don't show the "uninstall for all users" button for instant apps.
 164     @Test
 165     public void instantApps_noUninstallForAllButton() {
 166         // Make this app appear to be instant.
 167         ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
 168                 (InstantAppDataProvider) (i -> true));
 169         when(mDevicePolicyManager.packageHasActiveAdmins(nullable(String.class))).thenReturn(false);
 170         when(mUserManager.getUsers().size()).thenReturn(2);
 171
 172         final ApplicationInfo info = new ApplicationInfo();
 173         info.enabled = true;
 174         final AppEntry appEntry = mock(AppEntry.class);
 175         appEntry.info = info;
 176         final PackageInfo packageInfo = mock(PackageInfo.class);
 177
 178         ReflectionHelpers.setField(mFragment, "mDpm", mDevicePolicyManager);
 179         ReflectionHelpers.setField(mFragment, "mUserManager", mUserManager);
 180         ReflectionHelpers.setField(mFragment, "mPackageInfo", packageInfo);
 181
 182         assertThat(mFragment.shouldShowUninstallForAll(appEntry)).isFalse();
 183     }
 184
 185     @Test
 186     public void onActivityResult_uninstalledUpdates_shouldInvalidateOptionsMenu() {
 187         doReturn(true).when(mFragment).refreshUi();
 188
 189         mFragment.onActivityResult(mFragment.REQUEST_UNINSTALL, 0, mock(Intent.class));
 190
 191         verify(mActivity).invalidateOptionsMenu();
 192     }
 193
 194     @Test
 195     public void onActivityResult_packageUninstalled_shouldFinishAndRemoveTask() {
 196         doReturn(false).when(mFragment).refreshUi();
 197
 198         mFragment.onActivityResult(mFragment.REQUEST_UNINSTALL, 0, mock(Intent.class));
 199
 200         verify(mActivity).finishAndRemoveTask();
 201     }
 202
 203     @Test
 204     public void getPreferenceControllers_noPackageInfo_shouldReturnNull() {
 205         doNothing().when(mFragment).retrieveAppEntry();
 206
 207         assertThat(mFragment.getPreferenceControllers(mShadowContext)).isNull();
 208     }
 209
 210     @Test
 211     public void getNumberOfUserWithPackageInstalled_twoUsersInstalled_shouldReturnTwo()
 212             throws PackageManager.NameNotFoundException{
 213         final String packageName = "Package1";
 214         final int userID1 = 1;
 215         final int userID2 = 2;
 216         final List<UserInfo> userInfos = new ArrayList<>();
 217         userInfos.add(new UserInfo(userID1, "User1", UserInfo.FLAG_PRIMARY));
 218         userInfos.add(new UserInfo(userID2, "yue", UserInfo.FLAG_GUEST));
 219         when(mUserManager.getUsers(true)).thenReturn(userInfos);
 220         ReflectionHelpers.setField(mFragment, "mUserManager", mUserManager);
 221         final ApplicationInfo appInfo = new ApplicationInfo();
 222         appInfo.flags = ApplicationInfo.FLAG_INSTALLED;
 223         when(mPackageManager.getApplicationInfoAsUser(
 224                 packageName, PackageManager.GET_META_DATA, userID1))
 225                 .thenReturn(appInfo);
 226         when(mPackageManager.getApplicationInfoAsUser(
 227                 packageName, PackageManager.GET_META_DATA, userID2))
 228                 .thenReturn(appInfo);
 229         ReflectionHelpers.setField(mFragment, "mPm", mPackageManager);
 230
 231         assertThat(mFragment.getNumberOfUserWithPackageInstalled(packageName)).isEqualTo(2);
 232     }
 233
 234     @Test
 235     public void getNumberOfUserWithPackageInstalled_oneUserInstalled_shouldReturnOne()
 236             throws PackageManager.NameNotFoundException{
 237         final String packageName = "Package1";
 238         final int userID1 = 1;
 239         final int userID2 = 2;
 240         final List<UserInfo> userInfos = new ArrayList<>();
 241         userInfos.add(new UserInfo(userID1, "User1", UserInfo.FLAG_PRIMARY));
 242         userInfos.add(new UserInfo(userID2, "yue", UserInfo.FLAG_GUEST));
 243         when(mUserManager.getUsers(true)).thenReturn(userInfos);
 244         ReflectionHelpers.setField(mFragment, "mUserManager", mUserManager);
 245         final ApplicationInfo appInfo = new ApplicationInfo();
 246         appInfo.flags = ApplicationInfo.FLAG_INSTALLED;
 247         when(mPackageManager.getApplicationInfoAsUser(
 248                 packageName, PackageManager.GET_META_DATA, userID1))
 249                 .thenReturn(appInfo);
 250         when(mPackageManager.getApplicationInfoAsUser(
 251                 packageName, PackageManager.GET_META_DATA, userID2))
 252                 .thenThrow(new PackageManager.NameNotFoundException());
 253         ReflectionHelpers.setField(mFragment, "mPm", mPackageManager);
 254
 255         assertThat(mFragment.getNumberOfUserWithPackageInstalled(packageName)).isEqualTo(1);
 256
 257     }
 258 }