Home | History | Annotate | Download | only in enterprise
      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.enterprise;
     18 
     19 import static com.android.settings.testutils.ApplicationTestUtils.buildInfo;
     20 import static com.google.common.truth.Truth.assertThat;
     21 import static org.mockito.Answers.RETURNS_DEEP_STUBS;
     22 import static org.mockito.Matchers.any;
     23 import static org.mockito.Matchers.anyInt;
     24 import static org.mockito.Matchers.eq;
     25 import static org.mockito.Mockito.doReturn;
     26 import static org.mockito.Mockito.spy;
     27 import static org.mockito.Mockito.times;
     28 import static org.mockito.Mockito.verify;
     29 import static org.mockito.Mockito.when;
     30 
     31 import android.content.Context;
     32 import android.content.pm.PackageManager;
     33 import android.content.pm.UserInfo;
     34 import android.os.UserManager;
     35 import android.support.v7.preference.Preference;
     36 import android.support.v7.preference.PreferenceScreen;
     37 
     38 import com.android.settings.SettingsPreferenceFragment;
     39 import com.android.settings.applications.ApplicationFeatureProvider;
     40 import com.android.settings.applications.UserAppInfo;
     41 import com.android.settings.testutils.SettingsRobolectricTestRunner;
     42 
     43 import org.junit.Before;
     44 import org.junit.Test;
     45 import org.junit.runner.RunWith;
     46 import org.mockito.ArgumentCaptor;
     47 import org.mockito.Mock;
     48 import org.mockito.MockitoAnnotations;
     49 import org.robolectric.RuntimeEnvironment;
     50 
     51 import java.util.ArrayList;
     52 import java.util.Arrays;
     53 import java.util.HashSet;
     54 import java.util.List;
     55 import java.util.Set;
     56 
     57 @RunWith(SettingsRobolectricTestRunner.class)
     58 public class ApplicationListPreferenceControllerTest {
     59 
     60     private static final int MAIN_USER_ID = 0;
     61 
     62     private static final int MANAGED_PROFILE_ID = 10;
     63     private static final int PER_USER_UID_RANGE = 100000;
     64     private static final int MAIN_USER_APP_UID = MAIN_USER_ID * PER_USER_UID_RANGE;
     65     private static final int MANAGED_PROFILE_APP_UID = MANAGED_PROFILE_ID * PER_USER_UID_RANGE;
     66 
     67     private static final String APP_1 = "APP_1";
     68     private static final String APP_2 = "APP_2";
     69     private static final String APP_3 = "APP_3";
     70 
     71     @Mock(answer = RETURNS_DEEP_STUBS)
     72     private PreferenceScreen mScreen;
     73     @Mock(answer = RETURNS_DEEP_STUBS)
     74     private PackageManager mPackageManager;
     75     @Mock(answer = RETURNS_DEEP_STUBS)
     76     private SettingsPreferenceFragment mFragment;
     77     @Mock
     78     private UserManager mUserManager;
     79 
     80     private Context mContext;
     81     private ApplicationListPreferenceController mController;
     82 
     83     @Before
     84     public void setUp() {
     85         MockitoAnnotations.initMocks(this);
     86         mContext = spy(RuntimeEnvironment.application);
     87         doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
     88         when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
     89         when(mFragment.getPreferenceManager().getContext()).thenReturn(mContext);
     90         when(mPackageManager.getText(eq(APP_1), anyInt(), any())).thenReturn(APP_1);
     91         when(mPackageManager.getText(eq(APP_2), anyInt(), any())).thenReturn(APP_2);
     92         when(mPackageManager.getText(eq(APP_3), anyInt(), any())).thenReturn(APP_3);
     93 
     94         mController = new ApplicationListPreferenceController(mContext, new ThreeAppsBuilder(),
     95                 mPackageManager, mFragment);
     96     }
     97 
     98     @Test
     99     public void checkNumberAndTitlesOfApps() {
    100         ArgumentCaptor<Preference> apps = ArgumentCaptor.forClass(Preference.class);
    101         verify(mScreen, times(3)).addPreference(apps.capture());
    102         final Set<String> expectedPackages = new HashSet<>(Arrays.asList(APP_1, APP_2, APP_3));
    103         final Set<String> packages = new HashSet<>();
    104 
    105         for (Preference p : apps.getAllValues()) {
    106             packages.add(p.getTitle().toString());
    107         }
    108         assertThat(packages).isEqualTo(expectedPackages);
    109     }
    110 
    111     @Test
    112     public void isAvailable() {
    113         assertThat(mController.isAvailable()).isTrue();
    114     }
    115 
    116     @Test
    117     public void getPreferenceKey() {
    118         assertThat(mController.getPreferenceKey()).isNull();
    119     }
    120 
    121     private static class ThreeAppsBuilder
    122             implements ApplicationListPreferenceController.ApplicationListBuilder {
    123         @Override
    124         public void buildApplicationList(Context context,
    125                 ApplicationFeatureProvider.ListOfAppsCallback callback) {
    126             final List<UserAppInfo> apps = new ArrayList<>();
    127             final UserInfo user = new UserInfo(MAIN_USER_ID, "main", UserInfo.FLAG_ADMIN);
    128             apps.add(new UserAppInfo(user, buildInfo(MAIN_USER_APP_UID, APP_1, 0, 0)));
    129             apps.add(new UserAppInfo(user, buildInfo(MAIN_USER_APP_UID, APP_2, 0, 0)));
    130             apps.add(new UserAppInfo(user, buildInfo(MANAGED_PROFILE_APP_UID, APP_3, 0, 0)));
    131             callback.onListOfAppsResult(apps);
    132         }
    133     }
    134 }
    135