tests/robotests/src/com/android/settings/wifi/WifiSettingsTest.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 package com.android.settings.wifi;
  17
  18 import static com.google.common.truth.Truth.assertThat;
  19
  20 import static org.mockito.ArgumentMatchers.any;
  21 import static org.mockito.ArgumentMatchers.anyInt;
  22 import static org.mockito.ArgumentMatchers.eq;
  23 import static org.mockito.Mockito.doNothing;
  24 import static org.mockito.Mockito.doReturn;
  25 import static org.mockito.Mockito.mock;
  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.app.Activity;
  31 import android.content.ContentResolver;
  32 import android.content.Context;
  33 import android.content.Intent;
  34 import android.content.res.Resources;
  35 import android.os.Bundle;
  36 import android.os.PowerManager;
  37 import android.os.UserManager;
  38 import android.provider.Settings;
  39
  40 import android.view.ContextMenu;
  41 import android.view.View;
  42 import androidx.fragment.app.FragmentActivity;
  43 import androidx.preference.Preference;
  44
  45 import com.android.settings.R;
  46 import com.android.settings.datausage.DataUsagePreference;
  47 import com.android.settings.search.SearchIndexableRaw;
  48 import com.android.settings.testutils.shadow.ShadowDataUsageUtils;
  49 import com.android.settingslib.wifi.AccessPoint;
  50 import com.android.settingslib.wifi.WifiTracker;
  51
  52 import org.junit.Before;
  53 import org.junit.Test;
  54 import org.junit.runner.RunWith;
  55 import org.mockito.Mock;
  56 import org.mockito.MockitoAnnotations;
  57 import org.robolectric.RobolectricTestRunner;
  58 import org.robolectric.RuntimeEnvironment;
  59 import org.robolectric.annotation.Config;
  60
  61 import java.util.List;
  62
  63 @RunWith(RobolectricTestRunner.class)
  64 public class WifiSettingsTest {
  65
  66     private static final int NUM_NETWORKS = 4;
  67
  68     @Mock
  69     private WifiTracker mWifiTracker;
  70     @Mock
  71     private PowerManager mPowerManager;
  72     @Mock
  73     private DataUsagePreference mDataUsagePreference;
  74     private Context mContext;
  75     private WifiSettings mWifiSettings;
  76
  77     @Before
  78     public void setUp() {
  79         MockitoAnnotations.initMocks(this);
  80         mContext = spy(RuntimeEnvironment.application);
  81
  82         mWifiSettings = spy(new WifiSettings());
  83         doReturn(mContext).when(mWifiSettings).getContext();
  84         doReturn(mPowerManager).when(mContext).getSystemService(PowerManager.class);
  85         mWifiSettings.mAddWifiNetworkPreference = new AddWifiNetworkPreference(mContext);
  86         mWifiSettings.mSavedNetworksPreference = new Preference(mContext);
  87         mWifiSettings.mConfigureWifiSettingsPreference = new Preference(mContext);
  88         mWifiSettings.mWifiTracker = mWifiTracker;
  89     }
  90
  91     @Test
  92     public void testSearchIndexProvider_shouldIndexFragmentTitle() {
  93         final List<SearchIndexableRaw> indexRes =
  94                 WifiSettings.SEARCH_INDEX_DATA_PROVIDER.getRawDataToIndex(mContext,
  95                         true /* enabled */);
  96
  97         assertThat(indexRes).isNotNull();
  98         assertThat(indexRes.get(0).key).isEqualTo(WifiSettings.DATA_KEY_REFERENCE);
  99     }
 100
 101     @Test
 102     @Config(qualifiers = "mcc999")
 103     public void testSearchIndexProvider_ifWifiSettingsNotVisible_shouldNotIndexFragmentTitle() {
 104         final List<SearchIndexableRaw> indexRes =
 105                 WifiSettings.SEARCH_INDEX_DATA_PROVIDER.getRawDataToIndex(mContext,
 106                         true /* enabled */);
 107
 108         assertThat(indexRes).isEmpty();
 109     }
 110
 111     @Test
 112     public void addNetworkFragmentSendResult_onActivityResult_shouldHandleEvent() {
 113         final WifiSettings wifiSettings = spy(new WifiSettings());
 114         final Intent intent = new Intent();
 115         doNothing().when(wifiSettings).handleAddNetworkRequest(anyInt(), any(Intent.class));
 116
 117         wifiSettings.onActivityResult(WifiSettings.ADD_NETWORK_REQUEST, Activity.RESULT_OK, intent);
 118
 119         verify(wifiSettings).handleAddNetworkRequest(anyInt(), any(Intent.class));
 120     }
 121
 122     @Test
 123     public void setAdditionalSettingsSummaries_hasSavedNetwork_preferenceVisible() {
 124         when(mWifiTracker.getNumSavedNetworks()).thenReturn(NUM_NETWORKS);
 125
 126         mWifiSettings.setAdditionalSettingsSummaries();
 127
 128         assertThat(mWifiSettings.mSavedNetworksPreference.isVisible()).isTrue();
 129         assertThat(mWifiSettings.mSavedNetworksPreference.getSummary()).isEqualTo(
 130                 mContext.getResources().getQuantityString(
 131                         R.plurals.wifi_saved_access_points_summary,
 132                         NUM_NETWORKS, NUM_NETWORKS));
 133     }
 134
 135     @Test
 136     public void setAdditionalSettingsSummaries_noSavedNetwork_preferenceInvisible() {
 137         when(mWifiTracker.getNumSavedNetworks()).thenReturn(0);
 138
 139         mWifiSettings.setAdditionalSettingsSummaries();
 140
 141         assertThat(mWifiSettings.mSavedNetworksPreference.isVisible()).isFalse();
 142     }
 143
 144     @Test
 145     public void setAdditionalSettingsSummaries_wifiWakeupEnabled_displayOn() {
 146         final ContentResolver contentResolver = mContext.getContentResolver();
 147         Settings.Global.putInt(contentResolver, Settings.Global.WIFI_WAKEUP_ENABLED, 1);
 148         Settings.Global.putInt(contentResolver, Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE, 1);
 149         Settings.Global.putInt(contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0);
 150         when(mPowerManager.isPowerSaveMode()).thenReturn(false);
 151
 152         mWifiSettings.setAdditionalSettingsSummaries();
 153
 154         assertThat(mWifiSettings.mConfigureWifiSettingsPreference.getSummary()).isEqualTo(
 155                 mContext.getString(R.string.wifi_configure_settings_preference_summary_wakeup_on));
 156     }
 157
 158     @Test
 159     public void setAdditionalSettingsSummaries_wifiWakeupDisabled_displayOff() {
 160         final ContentResolver contentResolver = mContext.getContentResolver();
 161         Settings.Global.putInt(contentResolver, Settings.Global.WIFI_WAKEUP_ENABLED, 0);
 162
 163         mWifiSettings.setAdditionalSettingsSummaries();
 164
 165         assertThat(mWifiSettings.mConfigureWifiSettingsPreference.getSummary()).isEqualTo(
 166                 mContext.getString(R.string.wifi_configure_settings_preference_summary_wakeup_off));
 167     }
 168
 169     @Test
 170     public void checkAddWifiNetworkPrefernce_preferenceVisible() {
 171         assertThat(mWifiSettings.mAddWifiNetworkPreference.isVisible()).isTrue();
 172         assertThat(mWifiSettings.mAddWifiNetworkPreference.getTitle()).isEqualTo(
 173                 mContext.getString(R.string.wifi_add_network));
 174     }
 175
 176     private void setUpForOnCreate() {
 177         final FragmentActivity activity = mock(FragmentActivity.class);
 178         when(mWifiSettings.getActivity()).thenReturn(activity);
 179         final Resources.Theme theme = mContext.getTheme();
 180         when(activity.getTheme()).thenReturn(theme);
 181         UserManager userManager = mock(UserManager.class);
 182         when(activity.getSystemService(Context.USER_SERVICE))
 183                 .thenReturn(userManager);
 184
 185         when(mWifiSettings.findPreference(WifiSettings.PREF_KEY_DATA_USAGE))
 186                 .thenReturn(mDataUsagePreference);
 187     }
 188
 189     @Test
 190     @Config(shadows = {ShadowDataUsageUtils.class})
 191     public void checkDataUsagePreference_perferenceInvisibleIfWifiNotSupported() {
 192         setUpForOnCreate();
 193         ShadowDataUsageUtils.IS_WIFI_SUPPORTED = false;
 194
 195         mWifiSettings.onCreate(Bundle.EMPTY);
 196
 197         verify(mDataUsagePreference).setVisible(false);
 198     }
 199
 200     @Test
 201     @Config(shadows = {ShadowDataUsageUtils.class})
 202     public void checkDataUsagePreference_perferenceVisibleIfWifiSupported() {
 203         setUpForOnCreate();
 204         ShadowDataUsageUtils.IS_WIFI_SUPPORTED = true;
 205
 206         mWifiSettings.onCreate(Bundle.EMPTY);
 207
 208         verify(mDataUsagePreference).setVisible(true);
 209         verify(mDataUsagePreference).setTemplate(any(), eq(0) /*subId*/, eq(null) /*service*/);
 210     }
 211
 212     @Test
 213     public void onCreateContextMenu_shouldHaveForgetMenuForConnectedAccessPreference() {
 214         final FragmentActivity mockActivity = mock(FragmentActivity.class);
 215         when(mockActivity.getApplicationContext()).thenReturn(mContext);
 216         when(mWifiSettings.getActivity()).thenReturn(mockActivity);
 217
 218         final AccessPoint accessPoint = mock(AccessPoint.class);
 219         when(accessPoint.isConnectable()).thenReturn(false);
 220         when(accessPoint.isSaved()).thenReturn(true);
 221         when(accessPoint.isActive()).thenReturn(true);
 222
 223         final ConnectedAccessPointPreference connectedPreference =
 224             mWifiSettings.createConnectedAccessPointPreference(accessPoint, mContext);
 225         final View view = mock(View.class);
 226         when(view.getTag()).thenReturn(connectedPreference);
 227
 228         final ContextMenu menu = mock(ContextMenu.class);
 229         mWifiSettings.onCreateContextMenu(menu, view, null /* info */);
 230
 231         verify(menu).add(anyInt(), eq(WifiSettings.MENU_ID_FORGET), anyInt(), anyInt());
 232     }
 233 }