tests/robotests/src/com/android/settings/wifi/slice/WifiSliceTest.java

   1 /*
   2  * Copyright (C) 2018 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.wifi.slice;
  18
  19 import static android.app.slice.Slice.HINT_LIST_ITEM;
  20 import static android.app.slice.SliceItem.FORMAT_SLICE;
  21
  22 import static com.android.settings.wifi.slice.WifiSlice.DEFAULT_EXPANDED_ROW_COUNT;
  23
  24 import static com.google.common.truth.Truth.assertThat;
  25
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.doReturn;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.spy;
  30
  31 import android.content.ContentResolver;
  32 import android.content.Context;
  33 import android.content.Intent;
  34 import android.net.ConnectivityManager;
  35 import android.net.NetworkCapabilities;
  36 import android.net.NetworkInfo;
  37 import android.net.Uri;
  38 import android.net.wifi.WifiManager;
  39
  40 import androidx.core.graphics.drawable.IconCompat;
  41 import androidx.slice.Slice;
  42 import androidx.slice.SliceItem;
  43 import androidx.slice.SliceMetadata;
  44 import androidx.slice.SliceProvider;
  45 import androidx.slice.core.SliceAction;
  46 import androidx.slice.core.SliceQuery;
  47 import androidx.slice.widget.SliceLiveData;
  48
  49 import com.android.settings.R;
  50 import com.android.settings.slices.SliceBackgroundWorker;
  51 import com.android.settings.testutils.SliceTester;
  52 import com.android.settingslib.wifi.AccessPoint;
  53
  54 import java.util.ArrayList;
  55 import java.util.List;
  56
  57 import org.junit.Before;
  58 import org.junit.Test;
  59 import org.junit.runner.RunWith;
  60 import org.robolectric.RobolectricTestRunner;
  61 import org.robolectric.RuntimeEnvironment;
  62 import org.robolectric.annotation.Config;
  63 import org.robolectric.annotation.Implementation;
  64 import org.robolectric.annotation.Implements;
  65
  66 @RunWith(RobolectricTestRunner.class)
  67 @Config(shadows = WifiSliceTest.ShadowSliceBackgroundWorker.class)
  68 public class WifiSliceTest {
  69
  70     private static final String AP1_NAME = "ap1";
  71     private static final String AP2_NAME = "ap2";
  72
  73     private Context mContext;
  74     private ContentResolver mResolver;
  75     private WifiManager mWifiManager;
  76     private ConnectivityManager mConnectivityManager;
  77     private WifiSlice mWifiSlice;
  78
  79     @Before
  80     public void setUp() {
  81         mContext = spy(RuntimeEnvironment.application);
  82         mResolver = mock(ContentResolver.class);
  83         doReturn(mResolver).when(mContext).getContentResolver();
  84         mWifiManager = mContext.getSystemService(WifiManager.class);
  85
  86         // Set-up specs for SliceMetadata.
  87         SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);
  88         mWifiManager.setWifiEnabled(true);
  89
  90         mConnectivityManager = spy(mContext.getSystemService(ConnectivityManager.class));
  91         doReturn(mConnectivityManager).when(mContext).getSystemService(ConnectivityManager.class);
  92
  93         mWifiSlice = new WifiSlice(mContext);
  94     }
  95
  96     @Test
  97     public void getWifiSlice_shouldHaveTitleAndToggle() {
  98         final Slice wifiSlice = mWifiSlice.getSlice();
  99
 100         final SliceMetadata metadata = SliceMetadata.from(mContext, wifiSlice);
 101         assertThat(metadata.getTitle()).isEqualTo(mContext.getString(R.string.wifi_settings));
 102
 103         final List<SliceAction> toggles = metadata.getToggles();
 104         assertThat(toggles).hasSize(1);
 105
 106         final SliceAction primaryAction = metadata.getPrimaryAction();
 107         final IconCompat expectedToggleIcon = IconCompat.createWithResource(mContext,
 108                 R.drawable.ic_settings_wireless);
 109         assertThat(primaryAction.getIcon().toString()).isEqualTo(expectedToggleIcon.toString());
 110     }
 111
 112     @Test
 113     public void getWifiSlice_wifiOff_shouldReturnSingleRow() {
 114         mWifiManager.setWifiEnabled(false);
 115
 116         final Slice wifiSlice = mWifiSlice.getSlice();
 117
 118         final int rows = SliceQuery.findAll(wifiSlice, FORMAT_SLICE, HINT_LIST_ITEM,
 119                 null /* nonHints */).size();
 120
 121         // Title row
 122         assertThat(rows).isEqualTo(1);
 123     }
 124
 125     @Test
 126     public void getWifiSlice_noAp_shouldReturnLoadingRow() {
 127         final Slice wifiSlice = mWifiSlice.getSlice();
 128
 129         final int rows = SliceQuery.findAll(wifiSlice, FORMAT_SLICE, HINT_LIST_ITEM,
 130                 null /* nonHints */).size();
 131         final List<SliceItem> sliceItems = wifiSlice.getItems();
 132
 133         // All AP rows + title row
 134         assertThat(rows).isEqualTo(DEFAULT_EXPANDED_ROW_COUNT + 1);
 135         // Has scanning text
 136         SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
 137                 mContext.getString(R.string.wifi_empty_list_wifi_on));
 138     }
 139
 140     private AccessPoint createAccessPoint(String name, boolean active, boolean reachable) {
 141         final AccessPoint accessPoint = mock(AccessPoint.class);
 142         doReturn(name).when(accessPoint).getTitle();
 143         doReturn(active).when(accessPoint).isActive();
 144         doReturn(reachable).when(accessPoint).isReachable();
 145         if (active) {
 146             final NetworkInfo networkInfo = mock(NetworkInfo.class);
 147             doReturn(networkInfo).when(accessPoint).getNetworkInfo();
 148             doReturn(NetworkInfo.State.CONNECTED).when(networkInfo).getState();
 149         }
 150         return accessPoint;
 151     }
 152
 153     private void setWorkerResults(AccessPoint... accessPoints) {
 154         final ArrayList<AccessPoint> results = new ArrayList<>();
 155         for (AccessPoint ap : accessPoints) {
 156             results.add(ap);
 157         }
 158         final SliceBackgroundWorker worker = SliceBackgroundWorker.getInstance(mWifiSlice.getUri());
 159         doReturn(results).when(worker).getResults();
 160     }
 161
 162     @Test
 163     public void getWifiSlice_noReachableAp_shouldReturnLoadingRow() {
 164         setWorkerResults(
 165                 createAccessPoint(AP1_NAME, false, false),
 166                 createAccessPoint(AP2_NAME, false, false));
 167
 168         final Slice wifiSlice = mWifiSlice.getSlice();
 169         final List<SliceItem> sliceItems = wifiSlice.getItems();
 170
 171         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
 172         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP2_NAME);
 173         // Has scanning text
 174         SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
 175                 mContext.getString(R.string.wifi_empty_list_wifi_on));
 176     }
 177
 178     @Test
 179     public void getWifiSlice_oneActiveAp_shouldReturnLoadingRow() {
 180         setWorkerResults(createAccessPoint(AP1_NAME, true, true));
 181
 182         final Slice wifiSlice = mWifiSlice.getSlice();
 183         final List<SliceItem> sliceItems = wifiSlice.getItems();
 184
 185         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
 186         // Has scanning text
 187         SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
 188                 mContext.getString(R.string.wifi_empty_list_wifi_on));
 189     }
 190
 191     @Test
 192     public void getWifiSlice_oneActiveApAndOneUnreachableAp_shouldReturnLoadingRow() {
 193         setWorkerResults(
 194                 createAccessPoint(AP1_NAME, true, true),
 195                 createAccessPoint(AP2_NAME, false, false));
 196
 197         final Slice wifiSlice = mWifiSlice.getSlice();
 198         final List<SliceItem> sliceItems = wifiSlice.getItems();
 199
 200         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
 201         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP2_NAME);
 202         // Has scanning text
 203         SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
 204                 mContext.getString(R.string.wifi_empty_list_wifi_on));
 205     }
 206
 207     @Test
 208     public void getWifiSlice_oneReachableAp_shouldNotReturnLoadingRow() {
 209         setWorkerResults(createAccessPoint(AP1_NAME, false, true));
 210
 211         final Slice wifiSlice = mWifiSlice.getSlice();
 212         final List<SliceItem> sliceItems = wifiSlice.getItems();
 213
 214         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
 215         // No scanning text
 216         SliceTester.assertNoSliceItemContainsSubtitle(sliceItems,
 217                 mContext.getString(R.string.wifi_empty_list_wifi_on));
 218     }
 219
 220     @Test
 221     public void getWifiSlice_allReachableAps_shouldNotReturnLoadingRow() {
 222         setWorkerResults(
 223                 createAccessPoint(AP1_NAME, false, true),
 224                 createAccessPoint(AP2_NAME, false, true));
 225
 226         final Slice wifiSlice = mWifiSlice.getSlice();
 227         final List<SliceItem> sliceItems = wifiSlice.getItems();
 228
 229         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
 230         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP2_NAME);
 231         // No scanning text
 232         SliceTester.assertNoSliceItemContainsSubtitle(sliceItems,
 233                 mContext.getString(R.string.wifi_empty_list_wifi_on));
 234     }
 235
 236     @Test
 237     public void getWifiSlice_isCaptivePortal_shouldHaveCaptivePortalItems() {
 238         setWorkerResults(createAccessPoint(AP1_NAME, true, true));
 239         doReturn(makeCaptivePortalNetworkCapabilities()).when(mConnectivityManager)
 240                 .getNetworkCapabilities(any());
 241
 242         final Slice wifiSlice = mWifiSlice.getSlice();
 243         final List<SliceItem> sliceItems = wifiSlice.getItems();
 244
 245         SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
 246         assertCaptivePortalItems(sliceItems);
 247     }
 248
 249     private void assertCaptivePortalItems(List<SliceItem> sliceItems) {
 250         final String expectedSummary = mContext.getString(R.string.switch_on_text);
 251         SliceTester.assertAnySliceItemContainsSubtitle(sliceItems, expectedSummary);
 252
 253         final IconCompat expectedIcon = IconCompat.createWithResource(mContext,
 254                 R.drawable.ic_settings_accent);
 255         SliceTester.assertAnySliceItemContainsIcon(sliceItems, expectedIcon);
 256     }
 257
 258     static NetworkCapabilities makeCaptivePortalNetworkCapabilities() {
 259         final NetworkCapabilities nc = new NetworkCapabilities();
 260         nc.clearAll();
 261         nc.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
 262         nc.addCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL);
 263         return nc;
 264     }
 265
 266     @Test
 267     public void handleUriChange_updatesWifi() {
 268         final Intent intent = mWifiSlice.getIntent();
 269         intent.putExtra(android.app.slice.Slice.EXTRA_TOGGLE_STATE, true);
 270         final WifiManager wifiManager = mContext.getSystemService(WifiManager.class);
 271
 272         mWifiSlice.onNotifyChange(intent);
 273
 274         assertThat(wifiManager.getWifiState()).isEqualTo(WifiManager.WIFI_STATE_ENABLED);
 275     }
 276
 277     @Implements(SliceBackgroundWorker.class)
 278     public static class ShadowSliceBackgroundWorker {
 279         private static WifiScanWorker mWifiScanWorker = mock(WifiScanWorker.class);
 280
 281         @Implementation
 282         public static SliceBackgroundWorker getInstance(Uri uri) {
 283             return mWifiScanWorker;
 284         }
 285     }
 286 }