tests/unit/src/com/android/settings/wifi/WifiSettingsUiTest.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 android.support.test.InstrumentationRegistry.getInstrumentation;
  19 import static android.support.test.espresso.Espresso.onView;
  20 import static android.support.test.espresso.assertion.ViewAssertions.doesNotExist;
  21 import static android.support.test.espresso.assertion.ViewAssertions.matches;
  22 import static android.support.test.espresso.matcher.ViewMatchers.Visibility.VISIBLE;
  23 import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
  24 import static android.support.test.espresso.matcher.ViewMatchers.withEffectiveVisibility;
  25 import static android.support.test.espresso.matcher.ViewMatchers.withText;
  26
  27 import static com.google.common.truth.Truth.assertThat;
  28
  29 import static org.hamcrest.Matchers.allOf;
  30 import static org.hamcrest.Matchers.not;
  31 import static org.hamcrest.Matchers.startsWith;
  32 import static org.mockito.Mockito.atMost;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35
  36 import android.app.Activity;
  37 import android.app.Fragment;
  38 import android.content.Context;
  39 import android.content.Intent;
  40 import android.net.ConnectivityManager;
  41 import android.net.NetworkInfo;
  42 import android.net.wifi.WifiConfiguration;
  43 import android.net.wifi.WifiInfo;
  44 import android.net.wifi.WifiManager;
  45 import android.net.wifi.WifiSsid;
  46 import android.support.test.InstrumentationRegistry;
  47 import android.support.test.rule.ActivityTestRule;
  48 import android.support.test.runner.AndroidJUnit4;
  49
  50 import com.android.settings.Settings.WifiSettingsActivity;
  51 import com.android.settingslib.wifi.AccessPoint;
  52 import com.android.settingslib.wifi.TestAccessPointBuilder;
  53 import com.android.settingslib.wifi.WifiTracker;
  54 import com.android.settingslib.wifi.WifiTracker.WifiListener;
  55 import com.android.settingslib.wifi.WifiTrackerFactory;
  56
  57 import com.google.common.collect.Lists;
  58
  59 import org.junit.Before;
  60 import org.junit.Rule;
  61 import org.junit.Test;
  62 import org.junit.runner.RunWith;
  63 import org.mockito.Mock;
  64 import org.mockito.MockitoAnnotations;
  65
  66 import java.util.List;
  67
  68 @RunWith(AndroidJUnit4.class)
  69 public class WifiSettingsUiTest {
  70
  71     // TODO(b/37714546): Investigate why resource ids are not resolving correctly in the test apk,
  72     // then remove this manual string entry
  73     /** R.string.wifi_configure_settings_preference_title */
  74     private static final String WIFI_PREFERENCES = "Wi\u2011Fi preferences";
  75     /** R.string.wifi_saved_access_points_label */
  76     private static final String SAVED_NETWORKS = "Saved networks";
  77     /** R.string.wifi_empty_list_wifi_off */
  78     private static final String WIFI_OFF_MESSAGE = "To see available networks, turn Wi\u2011Fi on.";
  79     /** R.string.wifi_display_status_connected */
  80     private static final String CONNECTED = "Connected";
  81
  82     private static final String TEST_SSID = "\"Test Ssid\"";
  83     private static final String TEST_UNQUOTED_SSID = "Test Ssid";
  84     private static final String TEST_BSSID = "0a:08:5c:67:89:00";
  85     private static final int TEST_RSSI = 123;
  86     private static final int TEST_NETWORK_ID = 1;
  87
  88     @Mock
  89     private WifiTracker mWifiTracker;
  90     @Mock
  91     private WifiManager mWifiManager;
  92     private Context mContext;
  93     private WifiListener mWifiListener;
  94
  95     @Rule
  96     public ActivityTestRule<WifiSettingsActivity> mActivityRule =
  97             new ActivityTestRule<>(WifiSettingsActivity.class, true);
  98
  99     @Before
 100     public void setUp() {
 101         MockitoAnnotations.initMocks(this);
 102         mContext = InstrumentationRegistry.getTargetContext();
 103         WifiTrackerFactory.setTestingWifiTracker(mWifiTracker);
 104         when(mWifiTracker.getManager()).thenReturn(mWifiManager);
 105     }
 106
 107     private void setupConnectedAccessPoint() {
 108         WifiConfiguration config = new WifiConfiguration();
 109         config.SSID = TEST_SSID;
 110         config.BSSID = TEST_BSSID;
 111         config.networkId = TEST_NETWORK_ID;
 112         WifiInfo wifiInfo = new WifiInfo();
 113         wifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(TEST_UNQUOTED_SSID));
 114         wifiInfo.setBSSID(TEST_BSSID);
 115         wifiInfo.setRssi(TEST_RSSI);
 116         wifiInfo.setNetworkId(TEST_NETWORK_ID);
 117         NetworkInfo networkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, null, null);
 118         networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, null, null);
 119         AccessPoint accessPoint = new AccessPoint(mContext, config);
 120         accessPoint.update(config, wifiInfo, networkInfo);
 121
 122         assertThat(accessPoint.getSsidStr()).isEqualTo(TEST_UNQUOTED_SSID);
 123         assertThat(accessPoint.getBssid()).isEqualTo(TEST_BSSID);
 124         assertThat(accessPoint.getNetworkInfo()).isNotNull();
 125         assertThat(accessPoint.isActive()).isTrue();
 126         assertThat(accessPoint.getSettingsSummary()).isEqualTo(CONNECTED);
 127
 128         when(mWifiTracker.getAccessPoints()).thenReturn(
 129                 Lists.asList(accessPoint, new AccessPoint[]{}));
 130     }
 131
 132     private void launchActivity() {
 133         mActivityRule.launchActivity(new Intent("android.settings.WIFI_SETTINGS"));
 134
 135         verify(mWifiTracker).getManager();
 136
 137         List<Fragment> fragments = mActivityRule.getActivity().getFragmentManager().getFragments();
 138         assertThat(fragments.size()).isEqualTo(1);
 139         mWifiListener = (WifiSettings) fragments.get(0);
 140         assertThat(mWifiListener).isNotNull();
 141     }
 142
 143     private void setWifiState(int wifiState) {
 144         when(mWifiManager.getWifiState()).thenReturn(wifiState);
 145         when(mWifiManager.isWifiEnabled()).thenReturn(wifiState == WifiManager.WIFI_STATE_ENABLED);
 146     }
 147
 148     private void callOnWifiStateChanged(int state) {
 149         mActivityRule.getActivity().getMainThreadHandler()
 150                 .post(() -> mWifiListener.onWifiStateChanged(state));
 151     }
 152
 153     @Test
 154     public void launchActivityShouldSucceed() {
 155         launchActivity();
 156     }
 157
 158     @Test
 159     public void shouldShowWifiPreferences() {
 160         launchActivity();
 161
 162         onView(withText(WIFI_PREFERENCES)).check(matches(isDisplayed()));
 163     }
 164
 165     @Test
 166     public void noSavedNetworks_wifiEnabled_shouldNotShowSavedNetworksButton() {
 167         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 168         when(mWifiTracker.getNumSavedNetworks()).thenReturn(0);
 169
 170         launchActivity();
 171
 172         onView(withText(SAVED_NETWORKS)).check(matches(not(isDisplayed())));
 173     }
 174
 175     @Test
 176     public void noSavedNetworks_wifiDisabled_shouldNotShowSavedNetworksButton() {
 177         setWifiState(WifiManager.WIFI_STATE_DISABLED);
 178         when(mWifiTracker.getNumSavedNetworks()).thenReturn(0);
 179
 180         launchActivity();
 181
 182         onView(withText(SAVED_NETWORKS)).check(doesNotExist());
 183     }
 184
 185     @Test
 186     public void savedNetworksExist_shouldShowSavedNetworksButton() {
 187         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 188         when(mWifiTracker.getNumSavedNetworks()).thenReturn(1);
 189
 190         launchActivity();
 191
 192         onView(allOf(withText(SAVED_NETWORKS),
 193                 withEffectiveVisibility(VISIBLE))).check(matches(isDisplayed()));
 194     }
 195
 196     @Test
 197     public void onDisableWifi_seeOffMessage() {
 198         setWifiState(WifiManager.WIFI_STATE_DISABLED);
 199
 200         launchActivity();
 201         callOnWifiStateChanged(WifiManager.WIFI_STATE_DISABLED);
 202
 203         onView(withText(startsWith(WIFI_OFF_MESSAGE))).check(matches(isDisplayed()));
 204     }
 205
 206     @Test
 207     public void onEnableWifi_shouldNotSeeOffMessage() {
 208         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 209
 210         launchActivity();
 211         callOnWifiStateChanged(WifiManager.WIFI_STATE_ENABLED);
 212
 213         onView(withText(startsWith(WIFI_OFF_MESSAGE))).check(doesNotExist());
 214     }
 215
 216     @Test
 217     public void onConnected_shouldSeeConnectedMessage() {
 218         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 219         setupConnectedAccessPoint();
 220         when(mWifiTracker.isConnected()).thenReturn(true);
 221
 222         launchActivity();
 223
 224         onView(withText(CONNECTED)).check(matches(isDisplayed()));
 225     }
 226
 227     @Test
 228     public void resumingAp_shouldNotForceUpdateWhenExistingAPsAreListed() {
 229         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 230         setupConnectedAccessPoint();
 231         when(mWifiTracker.isConnected()).thenReturn(true);
 232
 233         launchActivity();
 234
 235         onView(withText(CONNECTED)).check(matches(isDisplayed()));
 236         verify(mWifiTracker).forceUpdate();
 237
 238         Activity activity = mActivityRule.getActivity();
 239         activity.finish();
 240         getInstrumentation().waitForIdleSync();
 241
 242         getInstrumentation().callActivityOnStart(activity);
 243         verify(mWifiTracker, atMost(1)).forceUpdate();
 244     }
 245
 246     @Test
 247     public void changingSecurityStateOnApShouldNotCauseMultipleListItems() {
 248         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 249         TestAccessPointBuilder builder = new TestAccessPointBuilder(mContext)
 250                 .setSsid(TEST_SSID).setSecurity(AccessPoint.SECURITY_NONE);
 251         AccessPoint open = builder.build();
 252
 253         builder.setSecurity(AccessPoint.SECURITY_EAP);
 254         AccessPoint eap = builder.build();
 255
 256         builder.setSecurity(AccessPoint.SECURITY_WEP);
 257         AccessPoint wep = builder.build();
 258
 259         // Return a different security state each time getAccessPoints is invoked
 260         when(mWifiTracker.getAccessPoints())
 261                 .thenReturn(Lists.newArrayList(open, eap))
 262                 .thenReturn(Lists.newArrayList(eap))
 263                 .thenReturn(Lists.newArrayList(wep));
 264
 265         launchActivity();
 266
 267         onView(withText(TEST_SSID)).check(matches(isDisplayed()));
 268
 269         mWifiListener.onAccessPointsChanged();
 270         onView(withText(TEST_SSID)).check(matches(isDisplayed()));
 271
 272         mWifiListener.onAccessPointsChanged();
 273         onView(withText(TEST_SSID)).check(matches(isDisplayed()));
 274     }
 275 }