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.WifiTracker;
  53 import com.android.settingslib.wifi.WifiTracker.WifiListener;
  54 import com.android.settingslib.wifi.WifiTrackerFactory;
  55
  56 import com.google.common.collect.Lists;
  57
  58 import org.junit.Before;
  59 import org.junit.Rule;
  60 import org.junit.Test;
  61 import org.junit.runner.RunWith;
  62 import org.mockito.Mock;
  63 import org.mockito.MockitoAnnotations;
  64
  65 import java.util.List;
  66
  67 @RunWith(AndroidJUnit4.class)
  68 public class WifiSettingsUiTest {
  69
  70     // TODO(b/37714546): Investigate why resource ids are not resolving correctly in the test apk,
  71     // then remove this manual string entry
  72     /** R.string.wifi_configure_settings_preference_title */
  73     private static final String WIFI_PREFERENCES = "Wi\u2011Fi preferences";
  74     /** R.string.wifi_saved_access_points_label */
  75     private static final String SAVED_NETWORKS = "Saved networks";
  76     /** R.string.wifi_empty_list_wifi_off */
  77     private static final String WIFI_OFF_MESSAGE = "To see available networks, turn Wi\u2011Fi on.";
  78     /** R.string.wifi_display_status_connected */
  79     private static final String CONNECTED = "Connected";
  80
  81     private static final String TEST_SSID = "\"Test Ssid\"";
  82     private static final String TEST_UNQUOTED_SSID = "Test Ssid";
  83     private static final String TEST_BSSID = "0a:08:5c:67:89:00";
  84     private static final int TEST_RSSI = 123;
  85     private static final int TEST_NETWORK_ID = 1;
  86
  87     @Mock private WifiTracker mWifiTracker;
  88     @Mock private WifiManager mWifiManager;
  89     private Context mContext;
  90     private WifiListener mWifiListener;
  91
  92     @Rule
  93     public ActivityTestRule<WifiSettingsActivity> mActivityRule =
  94             new ActivityTestRule<>(WifiSettingsActivity.class, true);
  95
  96     @Before
  97     public void setUp() {
  98         MockitoAnnotations.initMocks(this);
  99         mContext = InstrumentationRegistry.getTargetContext();
 100         WifiTrackerFactory.setTestingWifiTracker(mWifiTracker);
 101         when(mWifiTracker.getManager()).thenReturn(mWifiManager);
 102     }
 103
 104     private void setupConnectedAccessPoint() {
 105         WifiConfiguration config = new WifiConfiguration();
 106         config.SSID = TEST_SSID;
 107         config.BSSID = TEST_BSSID;
 108         config.networkId = TEST_NETWORK_ID;
 109         WifiInfo wifiInfo = new WifiInfo();
 110         wifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(TEST_UNQUOTED_SSID));
 111         wifiInfo.setBSSID(TEST_BSSID);
 112         wifiInfo.setRssi(TEST_RSSI);
 113         wifiInfo.setNetworkId(TEST_NETWORK_ID);
 114         NetworkInfo networkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, null, null);
 115         networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, null, null);
 116         AccessPoint accessPoint = new AccessPoint(mContext, config);
 117         accessPoint.update(config, wifiInfo, networkInfo);
 118
 119         assertThat(accessPoint.getSsidStr()).isEqualTo(TEST_UNQUOTED_SSID);
 120         assertThat(accessPoint.getBssid()).isEqualTo(TEST_BSSID);
 121         assertThat(accessPoint.getNetworkInfo()).isNotNull();
 122         assertThat(accessPoint.isActive()).isTrue();
 123         assertThat(accessPoint.getSettingsSummary()).isEqualTo(CONNECTED);
 124
 125         when(mWifiTracker.getAccessPoints()).thenReturn(
 126                 Lists.asList(accessPoint, new AccessPoint[]{}));
 127     }
 128
 129     private void launchActivity() {
 130         mActivityRule.launchActivity(new Intent("android.settings.WIFI_SETTINGS"));
 131
 132         verify(mWifiTracker).getManager();
 133
 134         List<Fragment> fragments = mActivityRule.getActivity().getFragmentManager().getFragments();
 135         assertThat(fragments.size()).isEqualTo(1);
 136         mWifiListener = (WifiSettings) fragments.get(0);
 137         assertThat(mWifiListener).isNotNull();
 138     }
 139
 140     private void setWifiState(int wifiState) {
 141         when(mWifiManager.getWifiState()).thenReturn(wifiState);
 142         when(mWifiManager.isWifiEnabled()).thenReturn(wifiState == WifiManager.WIFI_STATE_ENABLED);
 143     }
 144
 145     private void callOnWifiStateChanged(int state) {
 146         mActivityRule.getActivity().getMainThreadHandler()
 147                 .post( () -> mWifiListener.onWifiStateChanged(state) );
 148     }
 149
 150     @Test
 151     public void launchActivityShouldSucceed() {
 152         launchActivity();
 153     }
 154
 155     @Test
 156     public void shouldShowWifiPreferences() {
 157         launchActivity();
 158
 159         onView(withText(WIFI_PREFERENCES)).check(matches(isDisplayed()));
 160     }
 161
 162     @Test
 163     public void noSavedNetworks_shouldNotShowSavedNetworksButton() {
 164         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 165         when(mWifiTracker.getNumSavedNetworks()).thenReturn(0);
 166
 167         launchActivity();
 168
 169         onView(withText(SAVED_NETWORKS)).check(matches(not(isDisplayed())));
 170     }
 171
 172     @Test
 173     public void savedNetworksExist_shouldShowSavedNetworksButton() {
 174         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 175         when(mWifiTracker.getNumSavedNetworks()).thenReturn(1);
 176
 177         launchActivity();
 178
 179         onView(allOf(withText(SAVED_NETWORKS),
 180                 withEffectiveVisibility(VISIBLE))).check(matches(isDisplayed()));
 181     }
 182
 183     @Test
 184     public void onDisableWifi_seeOffMessage() {
 185         setWifiState(WifiManager.WIFI_STATE_DISABLED);
 186
 187         launchActivity();
 188         callOnWifiStateChanged(WifiManager.WIFI_STATE_DISABLED);
 189
 190         onView(withText(startsWith(WIFI_OFF_MESSAGE))).check(matches(isDisplayed()));
 191     }
 192
 193     @Test
 194     public void onEnableWifi_shouldNotSeeOffMessage() {
 195         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 196
 197         launchActivity();
 198         callOnWifiStateChanged(WifiManager.WIFI_STATE_ENABLED);
 199
 200         onView(withText(startsWith(WIFI_OFF_MESSAGE))).check(doesNotExist());
 201     }
 202
 203     @Test
 204     public void onConnected_shouldSeeConnectedMessage() {
 205         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 206         setupConnectedAccessPoint();
 207         when(mWifiTracker.isConnected()).thenReturn(true);
 208
 209         launchActivity();
 210
 211         onView(withText(CONNECTED)).check(matches(isDisplayed()));
 212     }
 213
 214     @Test
 215     public void resumingAp_shouldNotForceUpdateWhenExistingAPsAreListed() {
 216         setWifiState(WifiManager.WIFI_STATE_ENABLED);
 217         setupConnectedAccessPoint();
 218         when(mWifiTracker.isConnected()).thenReturn(true);
 219
 220         launchActivity();
 221
 222         onView(withText(CONNECTED)).check(matches(isDisplayed()));
 223         verify(mWifiTracker).forceUpdate();
 224
 225         Activity activity = mActivityRule.getActivity();
 226         activity.finish();
 227         getInstrumentation().waitForIdleSync();
 228
 229         getInstrumentation().callActivityOnStart(activity);
 230         verify(mWifiTracker, atMost(1)).forceUpdate();
 231     }
 232 }