1 /* 2 * Copyright (C) 2019 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.wifitrackerlib; 18 19 import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.DISABLED_AUTHENTICATION_FAILURE; 20 import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.DISABLED_AUTHENTICATION_NO_CREDENTIALS; 21 import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD; 22 import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.DISABLED_CONSECUTIVE_FAILURES; 23 import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLED; 24 import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED; 25 import static android.net.wifi.WifiInfo.SECURITY_TYPE_EAP; 26 import static android.net.wifi.WifiInfo.SECURITY_TYPE_OPEN; 27 import static android.net.wifi.WifiInfo.SECURITY_TYPE_OWE; 28 import static android.net.wifi.WifiInfo.SECURITY_TYPE_PSK; 29 import static android.net.wifi.WifiInfo.SECURITY_TYPE_SAE; 30 import static android.net.wifi.WifiInfo.SECURITY_TYPE_WEP; 31 32 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession; 33 import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify; 34 import static com.android.wifitrackerlib.StandardWifiEntry.ScanResultKey; 35 import static com.android.wifitrackerlib.StandardWifiEntry.StandardWifiEntryKey; 36 import static com.android.wifitrackerlib.StandardWifiEntry.ssidAndSecurityTypeToStandardWifiEntryKey; 37 import static com.android.wifitrackerlib.TestUtils.buildScanResult; 38 import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_CONNECTED; 39 import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_DISCONNECTED; 40 41 import static com.google.common.truth.Truth.assertThat; 42 43 import static org.junit.Assert.fail; 44 import static org.junit.Assume.assumeTrue; 45 import static org.mockito.Mockito.any; 46 import static org.mockito.Mockito.eq; 47 import static org.mockito.Mockito.mock; 48 import static org.mockito.Mockito.spy; 49 import static org.mockito.Mockito.times; 50 import static org.mockito.Mockito.when; 51 52 import android.app.admin.DevicePolicyManager; 53 import android.app.admin.WifiSsidPolicy; 54 import android.content.ComponentName; 55 import android.content.Context; 56 import android.content.res.Resources; 57 import android.net.ConnectivityDiagnosticsManager; 58 import android.net.ConnectivityManager; 59 import android.net.LinkProperties; 60 import android.net.MacAddress; 61 import android.net.Network; 62 import android.net.NetworkCapabilities; 63 import android.net.wifi.ScanResult; 64 import android.net.wifi.WifiConfiguration; 65 import android.net.wifi.WifiConfiguration.NetworkSelectionStatus; 66 import android.net.wifi.WifiEnterpriseConfig; 67 import android.net.wifi.WifiInfo; 68 import android.net.wifi.WifiManager; 69 import android.net.wifi.WifiSsid; 70 import android.os.Handler; 71 import android.os.UserHandle; 72 import android.os.UserManager; 73 import android.os.test.TestLooper; 74 import android.telephony.SubscriptionInfo; 75 import android.telephony.SubscriptionManager; 76 import android.telephony.TelephonyManager; 77 import android.util.ArraySet; 78 79 import androidx.core.os.BuildCompat; 80 81 import com.android.dx.mockito.inline.extended.ExtendedMockito; 82 83 import org.junit.Before; 84 import org.junit.Test; 85 import org.mockito.ArgumentCaptor; 86 import org.mockito.Mock; 87 import org.mockito.Mockito; 88 import org.mockito.MockitoAnnotations; 89 import org.mockito.MockitoSession; 90 91 import java.nio.charset.StandardCharsets; 92 import java.util.Arrays; 93 import java.util.Collections; 94 95 public class StandardWifiEntryTest { 96 @Mock private WifiEntry.WifiEntryCallback mMockListener; 97 @Mock private WifiEntry.ConnectCallback mMockConnectCallback; 98 @Mock private WifiManager mMockWifiManager; 99 @Mock private ConnectivityManager mMockConnectivityManager; 100 @Mock private SubscriptionManager mSubscriptionManager; 101 @Mock private WifiInfo mMockWifiInfo; 102 @Mock private Network mMockNetwork; 103 @Mock private NetworkCapabilities mMockNetworkCapabilities; 104 @Mock private WifiTrackerInjector mMockInjector; 105 @Mock private Context mMockContext; 106 @Mock private Resources mMockResources; 107 @Mock private UserManager mUserManager; 108 @Mock private DevicePolicyManager mDevicePolicyManager; 109 110 private TestLooper mTestLooper; 111 private Handler mTestHandler; 112 113 private static final String TEST_PACKAGE_NAME = "com.google.somePackage"; 114 private static final int MANAGED_PROFILE_UID = 1100000; 115 116 @Before setUp()117 public void setUp() { 118 MockitoAnnotations.initMocks(this); 119 120 mTestLooper = new TestLooper(); 121 mTestHandler = new Handler(mTestLooper.getLooper()); 122 123 when(mMockNetworkCapabilities.getTransportInfo()).thenReturn(mMockWifiInfo); 124 when(mMockWifiInfo.isPrimary()).thenReturn(true); 125 when(mMockWifiInfo.getNetworkId()).thenReturn(WifiConfiguration.INVALID_NETWORK_ID); 126 when(mMockWifiInfo.getRssi()).thenReturn(WifiInfo.INVALID_RSSI); 127 when(mMockWifiManager.isWpa3SaeSupported()).thenReturn(true); 128 when(mMockWifiManager.isEnhancedOpenSupported()).thenReturn(true); 129 when(mMockWifiManager.isWpa3SuiteBSupported()).thenReturn(true); 130 when(mMockWifiManager.calculateSignalLevel(TestUtils.GOOD_RSSI)) 131 .thenReturn(TestUtils.GOOD_LEVEL); 132 when(mMockWifiManager.calculateSignalLevel(TestUtils.OKAY_RSSI)) 133 .thenReturn(TestUtils.OKAY_LEVEL); 134 when(mMockWifiManager.calculateSignalLevel(TestUtils.BAD_RSSI)) 135 .thenReturn(TestUtils.BAD_LEVEL); 136 when(mMockInjector.getContext()).thenReturn(mMockContext); 137 when(mMockContext.getResources()).thenReturn(mMockResources); 138 139 when(mMockContext.getSystemService(ConnectivityManager.class)) 140 .thenReturn(mMockConnectivityManager); 141 when(mMockContext.getSystemService(SubscriptionManager.class)) 142 .thenReturn(mSubscriptionManager); 143 when(mMockContext.getSystemService(DevicePolicyManager.class)) 144 .thenReturn(mDevicePolicyManager); 145 when(mMockInjector.getUserManager()).thenReturn(mUserManager); 146 when(mMockInjector.getDevicePolicyManager()).thenReturn(mDevicePolicyManager); 147 } 148 149 /** 150 * Tests that constructing with a list of scans with differing SSIDs throws an exception 151 */ 152 @Test testConstructor_mismatchedSsids_throwsException()153 public void testConstructor_mismatchedSsids_throwsException() { 154 try { 155 new StandardWifiEntry( 156 mMockInjector, mTestHandler, 157 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 158 null, Arrays.asList( 159 buildScanResult("ssid0", "bssid0", 0, TestUtils.GOOD_RSSI), 160 buildScanResult("ssid1", "bssid1", 0, TestUtils.GOOD_RSSI)), 161 mMockWifiManager, false /* forSavedNetworksPage */); 162 fail("Scan list with different SSIDs should have thrown exception"); 163 } catch (IllegalArgumentException e) { 164 // Test succeeded 165 } 166 } 167 168 /** 169 * Tests that the level is set to the level of the strongest scan 170 */ 171 @Test testConstructor_scanResults_setsBestLevel()172 public void testConstructor_scanResults_setsBestLevel() { 173 final StandardWifiEntry entry = new StandardWifiEntry( 174 mMockInjector, mTestHandler, 175 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 176 null, Arrays.asList( 177 buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI), 178 buildScanResult("ssid", "bssid1", 0, TestUtils.OKAY_RSSI), 179 buildScanResult("ssid", "bssid2", 0, TestUtils.BAD_RSSI)), 180 mMockWifiManager, false /* forSavedNetworksPage */); 181 182 assertThat(entry.getLevel()).isEqualTo(TestUtils.GOOD_LEVEL); 183 } 184 185 /** 186 * Tests that the security is set to the security capabilities of the scan results if 187 * the entry is targeting new networks. 188 */ 189 @Test testConstructor_targetingNewSecurity_scanResultsSetSecurity()190 public void testConstructor_targetingNewSecurity_scanResultsSetSecurity() { 191 final ScanResult unsecureScan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 192 final ScanResult secureScan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 193 secureScan.capabilities = "EAP/SHA1"; 194 195 final StandardWifiEntry unsecureEntry = new StandardWifiEntry( 196 mMockInjector, mTestHandler, 197 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN, 198 true /* isTargetingNewNetworks */), 199 null, Arrays.asList(unsecureScan), mMockWifiManager, 200 false /* forSavedNetworksPage */); 201 final StandardWifiEntry secureEntry = new StandardWifiEntry( 202 mMockInjector, mTestHandler, 203 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP, 204 true /* isTargetingNewNetworks */), 205 null, Arrays.asList(secureScan), mMockWifiManager, 206 false /* forSavedNetworksPage */); 207 208 assertThat(unsecureEntry.getSecurity()).isEqualTo(WifiEntry.SECURITY_NONE); 209 assertThat(secureEntry.getSecurity()).isEqualTo(WifiEntry.SECURITY_EAP); 210 } 211 212 /** 213 * Tests that updating with a list of scans with differing SSIDs throws an exception 214 */ 215 @Test testUpdateScanResultInfo_mismatchedSsids_throwsException()216 public void testUpdateScanResultInfo_mismatchedSsids_throwsException() { 217 final StandardWifiEntry entry = new StandardWifiEntry( 218 mMockInjector, mTestHandler, 219 ssidAndSecurityTypeToStandardWifiEntryKey("ssid0", SECURITY_TYPE_EAP), 220 null, Arrays.asList(buildScanResult("ssid0", "bssid0", 0, TestUtils.GOOD_RSSI)), 221 mMockWifiManager, false /* forSavedNetworksPage */); 222 223 try { 224 entry.updateScanResultInfo(Arrays.asList( 225 buildScanResult("ssid1", "bssid1", 0, TestUtils.GOOD_RSSI))); 226 fail("Scan list with different SSIDs should have thrown exception"); 227 } catch (IllegalArgumentException e) { 228 // Test succeeded 229 } 230 } 231 232 /** 233 * Tests that the listener is notified after an update to the scan results 234 */ 235 @Test testUpdateScanResultInfo_notifiesListener()236 public void testUpdateScanResultInfo_notifiesListener() { 237 final StandardWifiEntry entry = new StandardWifiEntry( 238 mMockInjector, mTestHandler, 239 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 240 null, Arrays.asList(buildScanResult("ssid", "bssid", 0)), 241 mMockWifiManager, false /* forSavedNetworksPage */); 242 entry.setListener(mMockListener); 243 244 entry.updateScanResultInfo(Arrays.asList(buildScanResult("ssid", "bssid", 1))); 245 mTestLooper.dispatchAll(); 246 247 verify(mMockListener).onUpdated(); 248 } 249 250 /** 251 * Tests that the level is updated after an update to the scan results 252 */ 253 @Test testUpdateScanResultInfo_updatesLevel()254 public void testUpdateScanResultInfo_updatesLevel() { 255 final StandardWifiEntry entry = new StandardWifiEntry( 256 mMockInjector, mTestHandler, 257 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 258 null, Arrays.asList(buildScanResult("ssid", "bssid", 0, TestUtils.BAD_RSSI)), 259 mMockWifiManager, false /* forSavedNetworksPage */); 260 261 assertThat(entry.getLevel()).isEqualTo(TestUtils.BAD_LEVEL); 262 263 entry.updateScanResultInfo(Arrays.asList(buildScanResult("ssid", "bssid", 0, 264 TestUtils.GOOD_RSSI))); 265 266 assertThat(entry.getLevel()).isEqualTo(TestUtils.GOOD_LEVEL); 267 } 268 269 @Test testConstructor_wifiConfig_setsTitle()270 public void testConstructor_wifiConfig_setsTitle() { 271 final WifiConfiguration config = new WifiConfiguration(); 272 config.SSID = "\"ssid\""; 273 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 274 final StandardWifiEntry entry = new StandardWifiEntry( 275 mMockInjector, mTestHandler, 276 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 277 Collections.singletonList(config), null, mMockWifiManager, 278 false /* forSavedNetworksPage */); 279 280 assertThat(entry.getTitle()).isEqualTo("ssid"); 281 } 282 283 @Test testConstructor_wifiConfig_setsSecurity()284 public void testConstructor_wifiConfig_setsSecurity() { 285 final WifiConfiguration config = new WifiConfiguration(); 286 config.SSID = "\"ssid\""; 287 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 288 final StandardWifiEntry entry = new StandardWifiEntry( 289 mMockInjector, mTestHandler, 290 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 291 Collections.singletonList(config), null, mMockWifiManager, 292 false /* forSavedNetworksPage */); 293 294 assertThat(entry.getSecurity()).isEqualTo(WifiEntry.SECURITY_EAP); 295 } 296 297 @Test testUpdateConfig_mismatchedSsids_throwsException()298 public void testUpdateConfig_mismatchedSsids_throwsException() { 299 final WifiConfiguration config = new WifiConfiguration(); 300 config.SSID = "\"ssid\""; 301 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 302 final StandardWifiEntry entry = new StandardWifiEntry( 303 mMockInjector, mTestHandler, 304 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 305 Collections.singletonList(config), null, mMockWifiManager, 306 false /* forSavedNetworksPage */); 307 308 final WifiConfiguration config2 = new WifiConfiguration(config); 309 config2.SSID = "\"ssid2\""; 310 try { 311 entry.updateConfig(Collections.singletonList(config2)); 312 fail("Updating with wrong SSID config should throw exception"); 313 } catch (IllegalArgumentException e) { 314 // Test Succeeded 315 } 316 } 317 318 @Test testUpdateConfig_mismatchedSecurity_throwsException()319 public void testUpdateConfig_mismatchedSecurity_throwsException() { 320 final WifiConfiguration config = new WifiConfiguration(); 321 config.SSID = "\"ssid\""; 322 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 323 final StandardWifiEntry entry = new StandardWifiEntry( 324 mMockInjector, mTestHandler, 325 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 326 Collections.singletonList(config), null, mMockWifiManager, 327 false /* forSavedNetworksPage */); 328 329 final WifiConfiguration config2 = new WifiConfiguration(config); 330 config2.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 331 try { 332 entry.updateConfig(Collections.singletonList(config2)); 333 fail("Updating with wrong security config should throw exception"); 334 } catch (IllegalArgumentException e) { 335 // Test Succeeded 336 } 337 } 338 339 @Test testUpdateConfig_unsavedToSaved()340 public void testUpdateConfig_unsavedToSaved() { 341 final ScanResult scan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 342 scan.capabilities = "EAP/SHA1"; 343 final StandardWifiEntry entry = new StandardWifiEntry( 344 mMockInjector, mTestHandler, 345 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 346 null, Arrays.asList(scan), mMockWifiManager, 347 false /* forSavedNetworksPage */); 348 assertThat(entry.needsWifiConfiguration()).isTrue(); 349 assertThat(entry.isSaved()).isFalse(); 350 351 final WifiConfiguration config = new WifiConfiguration(); 352 config.SSID = "\"ssid\""; 353 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 354 config.networkId = 1; 355 entry.updateConfig(Collections.singletonList(config)); 356 357 assertThat(entry.needsWifiConfiguration()).isFalse(); 358 assertThat(entry.isSaved()).isTrue(); 359 } 360 361 @Test testUpdateConfig_savedToUnsaved()362 public void testUpdateConfig_savedToUnsaved() { 363 final WifiConfiguration config = new WifiConfiguration(); 364 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 365 config.SSID = "\"ssid\""; 366 config.networkId = 1; 367 final StandardWifiEntry entry = new StandardWifiEntry( 368 mMockInjector, mTestHandler, 369 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 370 Collections.singletonList(config), null, mMockWifiManager, 371 false /* forSavedNetworksPage */); 372 assertThat(entry.needsWifiConfiguration()).isFalse(); 373 assertThat(entry.isSaved()).isTrue(); 374 375 entry.updateConfig(null); 376 377 assertThat(entry.needsWifiConfiguration()).isTrue(); 378 assertThat(entry.isSaved()).isFalse(); 379 } 380 381 @Test testOnNetworkCapabilitiesChanged_matchingNetworkId_becomesConnected()382 public void testOnNetworkCapabilitiesChanged_matchingNetworkId_becomesConnected() { 383 final WifiConfiguration config = new WifiConfiguration(); 384 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 385 config.SSID = "\"ssid\""; 386 config.networkId = 1; 387 final StandardWifiEntry entry = new StandardWifiEntry( 388 mMockInjector, mTestHandler, 389 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 390 Collections.singletonList(config), null, mMockWifiManager, 391 false /* forSavedNetworksPage */); 392 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 393 394 // Ignore non-matching network id 395 when(mMockWifiInfo.getNetworkId()).thenReturn(2); 396 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 397 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_DISCONNECTED); 398 399 // Matching network id should result in connected 400 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 401 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 402 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED); 403 } 404 405 @Test testOnNetworkLost_matchingNetwork_becomesDisconnected()406 public void testOnNetworkLost_matchingNetwork_becomesDisconnected() { 407 final WifiConfiguration config = new WifiConfiguration(); 408 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 409 config.SSID = "\"ssid\""; 410 config.networkId = 1; 411 final StandardWifiEntry entry = new StandardWifiEntry( 412 mMockInjector, mTestHandler, 413 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 414 Collections.singletonList(config), null, mMockWifiManager, 415 false /* forSavedNetworksPage */); 416 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 417 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 418 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 419 420 // Non-matching network loss should be ignored 421 entry.onNetworkLost(mock(Network.class)); 422 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED); 423 424 // Matching network loss should result in disconnected 425 entry.onNetworkLost(mMockNetwork); 426 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_DISCONNECTED); 427 } 428 429 @Test testOnNetworkCapabilitiesChanged_notPrimaryAnymore_becomesDisconnected()430 public void testOnNetworkCapabilitiesChanged_notPrimaryAnymore_becomesDisconnected() { 431 final WifiConfiguration config = new WifiConfiguration(); 432 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 433 config.SSID = "\"ssid\""; 434 config.networkId = 1; 435 final StandardWifiEntry entry = new StandardWifiEntry( 436 mMockInjector, mTestHandler, 437 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 438 Collections.singletonList(config), null, mMockWifiManager, 439 false /* forSavedNetworksPage */); 440 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 441 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 442 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 443 444 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 445 try { 446 ExtendedMockito.doReturn(false).when(() -> NonSdkApiWrapper.isPrimary(any())); 447 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 448 } finally { 449 session.finishMocking(); 450 } 451 452 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_DISCONNECTED); 453 } 454 455 @Test testOnNetworkCapabilitiesChanged_nonPrimaryOem_becomesConnected()456 public void testOnNetworkCapabilitiesChanged_nonPrimaryOem_becomesConnected() { 457 final WifiConfiguration config = new WifiConfiguration(); 458 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 459 config.SSID = "\"ssid\""; 460 config.networkId = 1; 461 final StandardWifiEntry entry = new StandardWifiEntry( 462 mMockInjector, mTestHandler, 463 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 464 Collections.singletonList(config), null, mMockWifiManager, 465 false /* forSavedNetworksPage */); 466 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 467 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 468 469 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 470 try { 471 ExtendedMockito.doReturn(false) 472 .when(() -> NonSdkApiWrapper.isPrimary(mMockWifiInfo)); 473 // Is OEM 474 ExtendedMockito.doReturn(true) 475 .when(() -> NonSdkApiWrapper.isOemCapabilities(mMockNetworkCapabilities)); 476 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 477 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED); 478 479 // Not OEM anymore 480 ExtendedMockito.doReturn(false) 481 .when(() -> NonSdkApiWrapper.isOemCapabilities(mMockNetworkCapabilities)); 482 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 483 assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_DISCONNECTED); 484 } finally { 485 session.finishMocking(); 486 } 487 } 488 489 @Test testConnect_savedNetwork_usesSavedConfig()490 public void testConnect_savedNetwork_usesSavedConfig() { 491 final ScanResult scan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 492 final StandardWifiEntry entry = new StandardWifiEntry( 493 mMockInjector, mTestHandler, 494 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 495 null, Arrays.asList(scan), mMockWifiManager, 496 false /* forSavedNetworksPage */); 497 final WifiConfiguration config = new WifiConfiguration(); 498 config.SSID = "\"ssid\""; 499 config.networkId = 1; 500 entry.updateConfig(Collections.singletonList(config)); 501 502 entry.connect(null /* ConnectCallback */); 503 504 verify(mMockWifiManager, times(1)).connect(eq(1), any()); 505 } 506 507 @Test testConnect_savedNetwork_usesSavedConfig_withOutSim()508 public void testConnect_savedNetwork_usesSavedConfig_withOutSim() { 509 final ScanResult scan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 510 final StandardWifiEntry entry = new StandardWifiEntry( 511 mMockInjector, mTestHandler, 512 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 513 null, Arrays.asList(scan), mMockWifiManager, 514 false /* forSavedNetworksPage */); 515 final WifiConfiguration config = new WifiConfiguration(); 516 config.SSID = "\"ssid\""; 517 config.networkId = 1; 518 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 519 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 520 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 521 entry.updateConfig(Collections.singletonList(config)); 522 when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(null); 523 524 entry.setListener(mMockListener); 525 entry.connect(mMockConnectCallback); 526 mTestLooper.dispatchAll(); 527 verify(mMockConnectCallback, times(1)) 528 .onConnectResult(WifiEntry.ConnectCallback.CONNECT_STATUS_FAILURE_SIM_ABSENT); 529 } 530 531 @Test testConnect_openNetwork_callsConnect()532 public void testConnect_openNetwork_callsConnect() { 533 final StandardWifiEntry entry = new StandardWifiEntry( 534 mMockInjector, mTestHandler, 535 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 536 null, Arrays.asList(buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI)), 537 mMockWifiManager, false /* forSavedNetworksPage */); 538 assertThat(entry.needsWifiConfiguration()).isFalse(); 539 assertThat(entry.isSaved()).isFalse(); 540 541 entry.connect(null /* ConnectCallback */); 542 543 verify(mMockWifiManager, times(1)).connect(any(), any()); 544 } 545 546 @Test testConnect_unsavedSecureNetwork_returnsNoConfigFailure()547 public void testConnect_unsavedSecureNetwork_returnsNoConfigFailure() { 548 final ScanResult secureScan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 549 secureScan.capabilities = "PSK"; 550 final StandardWifiEntry entry = new StandardWifiEntry( 551 mMockInjector, mTestHandler, 552 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 553 null, Arrays.asList(secureScan), mMockWifiManager, 554 false /* forSavedNetworksPage */); 555 entry.setListener(mMockListener); 556 557 entry.connect(mMockConnectCallback); 558 mTestLooper.dispatchAll(); 559 560 verify(mMockConnectCallback, times(1)) 561 .onConnectResult(WifiEntry.ConnectCallback.CONNECT_STATUS_FAILURE_NO_CONFIG); 562 } 563 564 @Test testGetMacAddress_randomizationOn_usesRandomizedValue()565 public void testGetMacAddress_randomizationOn_usesRandomizedValue() { 566 final String randomizedMac = "01:23:45:67:89:ab"; 567 final WifiConfiguration config = new WifiConfiguration(); 568 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 569 config.SSID = "\"ssid\""; 570 config.networkId = 1; 571 config.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_AUTO; 572 WifiConfiguration spyConfig = spy(config); 573 when(spyConfig.getRandomizedMacAddress()) 574 .thenReturn(MacAddress.fromString(randomizedMac)); 575 576 final StandardWifiEntry entry = new StandardWifiEntry( 577 mMockInjector, mTestHandler, 578 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 579 Collections.singletonList(spyConfig), null, mMockWifiManager, 580 false /* forSavedNetworksPage */); 581 582 final String macAddress = entry.getMacAddress(); 583 584 assertThat(macAddress).isEqualTo(randomizedMac); 585 } 586 587 @Test testGetMacAddress_randomizationOff_usesDeviceMac()588 public void testGetMacAddress_randomizationOff_usesDeviceMac() { 589 final String factoryMac = "01:23:45:67:89:ab"; 590 final WifiConfiguration config = new WifiConfiguration(); 591 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 592 config.SSID = "\"ssid\""; 593 config.networkId = 1; 594 config.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 595 when(mMockWifiManager.getFactoryMacAddresses()).thenReturn(new String[]{factoryMac}); 596 final StandardWifiEntry entry = new StandardWifiEntry( 597 mMockInjector, mTestHandler, 598 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 599 Collections.singletonList(config), null, mMockWifiManager, 600 false /* forSavedNetworksPage */); 601 602 final String macAddress = entry.getMacAddress(); 603 604 assertThat(macAddress).isEqualTo(factoryMac); 605 } 606 607 @Test testGetMacAddress_wifiInfoAvailable_usesWifiInfoMacAddress()608 public void testGetMacAddress_wifiInfoAvailable_usesWifiInfoMacAddress() { 609 final int networkId = 1; 610 final String factoryMac = "01:23:45:67:89:ab"; 611 final String wifiInfoMac = "11:23:45:67:89:ab"; 612 613 when(mMockWifiInfo.getNetworkId()).thenReturn(networkId); 614 when(mMockWifiInfo.getMacAddress()).thenReturn(wifiInfoMac); 615 final WifiConfiguration config = new WifiConfiguration(); 616 config.SSID = "\"ssid\""; 617 config.networkId = networkId; 618 config.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 619 when(mMockWifiManager.getFactoryMacAddresses()).thenReturn(new String[]{factoryMac}); 620 final StandardWifiEntry entry = new StandardWifiEntry( 621 mMockInjector, mTestHandler, 622 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 623 Collections.singletonList(config), null, mMockWifiManager, 624 false /* forSavedNetworksPage */); 625 626 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 627 628 assertThat(entry.getMacAddress()).isEqualTo(wifiInfoMac); 629 } 630 631 @Test testCanShare_securityCanShare_shouldReturnTrue()632 public void testCanShare_securityCanShare_shouldReturnTrue() { 633 final StandardWifiEntry pskWifiEntry = 634 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 635 final StandardWifiEntry wepWifiEntry = 636 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_WEP); 637 final StandardWifiEntry openWifiEntry = 638 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_OPEN); 639 final StandardWifiEntry saeWifiEntry = 640 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_SAE); 641 final StandardWifiEntry oweWifiEntry = 642 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_OWE); 643 644 assertThat(pskWifiEntry.canShare()).isTrue(); 645 assertThat(wepWifiEntry.canShare()).isTrue(); 646 assertThat(openWifiEntry.canShare()).isTrue(); 647 assertThat(saeWifiEntry.canShare()).isTrue(); 648 assertThat(oweWifiEntry.canShare()).isTrue(); 649 } 650 651 @Test testCanShare_securityCanNotShare_shouldReturnFalse()652 public void testCanShare_securityCanNotShare_shouldReturnFalse() { 653 final StandardWifiEntry eapWifiEntry = 654 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_EAP); 655 final StandardWifiEntry eapSuiteBWifiEntry = 656 getSavedStandardWifiEntry( 657 WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 658 659 assertThat(eapWifiEntry.canShare()).isFalse(); 660 assertThat(eapSuiteBWifiEntry.canShare()).isFalse(); 661 } 662 663 @Test testCanEasyConnect_deviceNotSupported_shouldReturnFalse()664 public void testCanEasyConnect_deviceNotSupported_shouldReturnFalse() { 665 when(mMockWifiManager.isEasyConnectSupported()).thenReturn(false); 666 final ScanResult pskScanResult = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 667 pskScanResult.capabilities = "PSK"; 668 669 final StandardWifiEntry pskWifiEntry = new StandardWifiEntry( 670 mMockInjector, mTestHandler, 671 ssidAndSecurityTypeToStandardWifiEntryKey(pskScanResult.SSID, SECURITY_TYPE_PSK), 672 null, Arrays.asList(pskScanResult), mMockWifiManager, 673 false /* forSavedNetworksPage */); 674 675 assertThat(pskWifiEntry.canEasyConnect()).isFalse(); 676 } 677 678 @Test testCanEasyConnect_securityCanEasyConnect_shouldReturnTrue()679 public void testCanEasyConnect_securityCanEasyConnect_shouldReturnTrue() { 680 when(mMockWifiManager.isEasyConnectSupported()).thenReturn(true); 681 final StandardWifiEntry pskWifiEntry = 682 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 683 final StandardWifiEntry saeWifiEntry = 684 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_SAE); 685 686 assertThat(pskWifiEntry.canEasyConnect()).isTrue(); 687 assertThat(saeWifiEntry.canEasyConnect()).isTrue(); 688 } 689 690 @Test testCanEasyConnect_securityCanNotEasyConnect_shouldReturnFalse()691 public void testCanEasyConnect_securityCanNotEasyConnect_shouldReturnFalse() { 692 when(mMockWifiManager.isEasyConnectSupported()).thenReturn(true); 693 final StandardWifiEntry openWifiEntry = 694 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_OPEN); 695 final StandardWifiEntry wepWifiEntry = 696 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_WEP); 697 final StandardWifiEntry wpa2EnterpriseWifiEntry = 698 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_EAP); 699 final StandardWifiEntry wpa3EnterpriseWifiEntry = 700 getSavedStandardWifiEntry( 701 WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 702 final StandardWifiEntry oweWifiEntry = 703 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_OWE); 704 705 assertThat(openWifiEntry.canEasyConnect()).isFalse(); 706 assertThat(wepWifiEntry.canEasyConnect()).isFalse(); 707 assertThat(wpa2EnterpriseWifiEntry.canEasyConnect()).isFalse(); 708 assertThat(wpa3EnterpriseWifiEntry.canEasyConnect()).isFalse(); 709 assertThat(oweWifiEntry.canEasyConnect()).isFalse(); 710 } 711 712 @Test testUpdateLinkProperties_updatesConnectedInfo()713 public void testUpdateLinkProperties_updatesConnectedInfo() { 714 final WifiConfiguration config = new WifiConfiguration(); 715 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 716 config.SSID = "\"ssid\""; 717 config.networkId = 1; 718 final StandardWifiEntry entry = new StandardWifiEntry( 719 mMockInjector, mTestHandler, 720 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 721 Collections.singletonList(config), null, mMockWifiManager, 722 false /* forSavedNetworksPage */); 723 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 724 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 725 726 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 727 728 entry.updateLinkProperties(mMockNetwork, new LinkProperties()); 729 730 assertThat(entry.getConnectedInfo()).isNotNull(); 731 } 732 getSavedStandardWifiEntry(int wifiConfigurationSecureType)733 private StandardWifiEntry getSavedStandardWifiEntry(int wifiConfigurationSecureType) { 734 final WifiConfiguration config = new WifiConfiguration(); 735 config.SSID = "\"ssid\""; 736 config.setSecurityParams(wifiConfigurationSecureType); 737 return new StandardWifiEntry( 738 mMockInjector, mTestHandler, 739 new StandardWifiEntryKey(config), Collections.singletonList(config), null, 740 mMockWifiManager, false /* forSavedNetworksPage */); 741 } 742 getSavedDOStandardWifiEntry(int wifiConfigurationSecureType)743 private StandardWifiEntry getSavedDOStandardWifiEntry(int wifiConfigurationSecureType) { 744 final WifiConfiguration config = new WifiConfiguration(); 745 config.SSID = "\"ssid\""; 746 config.setSecurityParams(wifiConfigurationSecureType); 747 config.creatorUid = MANAGED_PROFILE_UID; 748 config.creatorName = TEST_PACKAGE_NAME; 749 return new StandardWifiEntry( 750 mMockInjector, mTestHandler, 751 new StandardWifiEntryKey(config), Collections.singletonList(config), null, 752 mMockWifiManager, false /* forSavedNetworksPage */); 753 } 754 755 @Test testGetSummary_connectedWifiNetwork_showsConnected()756 public void testGetSummary_connectedWifiNetwork_showsConnected() { 757 final int networkId = 1; 758 final String summarySeparator = " / "; 759 final String[] wifiStatusArray = new String[]{"", "Scanning", "Connecting", 760 "Authenticating", "Obtaining IP address", "Connected"}; 761 762 when(mMockContext.getString(R.string.wifitrackerlib_summary_separator)) 763 .thenReturn(summarySeparator); 764 when(mMockContext.getResources()).thenReturn(mMockResources); 765 when(mMockResources.getStringArray(R.array.wifitrackerlib_wifi_status)) 766 .thenReturn(wifiStatusArray); 767 when(mMockNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) 768 .thenReturn(true); 769 final WifiConfiguration config = new WifiConfiguration(); 770 config.SSID = "\"ssid\""; 771 config.networkId = networkId; 772 final StandardWifiEntry entry = new StandardWifiEntry( 773 mMockInjector, mTestHandler, 774 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 775 Collections.singletonList(config), null, mMockWifiManager, 776 false /* forSavedNetworksPage */); 777 778 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 779 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 780 781 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 782 entry.onDefaultNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 783 784 assertThat(entry.getSummary()).isEqualTo("Connected"); 785 } 786 787 @Test testGetSummary_connectedButNotDefault_doesNotShowConnected()788 public void testGetSummary_connectedButNotDefault_doesNotShowConnected() { 789 final int networkId = 1; 790 final String summarySeparator = " / "; 791 final String[] wifiStatusArray = new String[]{"", "Scanning", "Connecting", 792 "Authenticating", "Obtaining IP address", "Connected"}; 793 794 when(mMockContext.getString(R.string.wifitrackerlib_summary_separator)) 795 .thenReturn(summarySeparator); 796 when(mMockResources.getStringArray(R.array.wifitrackerlib_wifi_status)) 797 .thenReturn(wifiStatusArray); 798 799 final WifiConfiguration config = new WifiConfiguration(); 800 config.SSID = "\"ssid\""; 801 config.networkId = networkId; 802 final StandardWifiEntry entry = new StandardWifiEntry( 803 mMockInjector, mTestHandler, 804 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 805 Collections.singletonList(config), null, mMockWifiManager, 806 false /* forSavedNetworksPage */); 807 when(mMockWifiInfo.getNetworkId()).thenReturn(networkId); 808 809 when(mMockNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) 810 .thenReturn(true); 811 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 812 Network otherNetwork = mock(Network.class); 813 when(otherNetwork.getNetId()).thenReturn(2); 814 entry.onDefaultNetworkCapabilitiesChanged(otherNetwork, new NetworkCapabilities()); 815 816 assertThat(entry.getSummary()).isEqualTo(""); 817 } 818 819 @Test testShouldShowXLevelIcon_unvalidatedOrNotDefault_returnsTrue()820 public void testShouldShowXLevelIcon_unvalidatedOrNotDefault_returnsTrue() { 821 final int networkId = 1; 822 final WifiConfiguration config = new WifiConfiguration(); 823 config.SSID = "\"ssid\""; 824 config.networkId = networkId; 825 826 final StandardWifiEntry entry = new StandardWifiEntry( 827 mMockInjector, mTestHandler, 828 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 829 Collections.singletonList(config), null, mMockWifiManager, 830 false /* forSavedNetworksPage */); 831 832 // Disconnected should return false; 833 assertThat(entry.shouldShowXLevelIcon()).isEqualTo(false); 834 835 // Connected but validation attempt not complete, should not show X level icon yet. 836 when(mMockWifiInfo.getNetworkId()).thenReturn(networkId); 837 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 838 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 839 assertThat(entry.shouldShowXLevelIcon()).isEqualTo(false); 840 841 // Validation attempt complete, should show X level icon. 842 ConnectivityDiagnosticsManager.ConnectivityReport connectivityReport = mock( 843 ConnectivityDiagnosticsManager.ConnectivityReport.class); 844 when(connectivityReport.getNetwork()).thenReturn(mMockNetwork); 845 entry.updateConnectivityReport(connectivityReport); 846 assertThat(entry.shouldShowXLevelIcon()).isEqualTo(true); 847 848 // Internet validated, should not show X level icon. 849 when(mMockNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) 850 .thenReturn(true); 851 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 852 assertThat(entry.shouldShowXLevelIcon()).isEqualTo(false); 853 854 // Cell becomes default (i.e. low quality wifi), show X level icon. 855 entry.onDefaultNetworkCapabilitiesChanged(Mockito.mock(Network.class), 856 new NetworkCapabilities.Builder() 857 .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR).build()); 858 assertThat(entry.shouldShowXLevelIcon()).isEqualTo(true); 859 } 860 861 @Test testGetSecurityString_pskAndSae_getWpaWpa2Wpa3Personal()862 public void testGetSecurityString_pskAndSae_getWpaWpa2Wpa3Personal() { 863 final String wifiSecurityShortWpaWpa2Wpa3 = "WPA/WPA2/WPA3"; 864 when(mMockContext.getString(R.string.wifitrackerlib_wifi_security_short_wpa_wpa2_wpa3)) 865 .thenReturn(wifiSecurityShortWpaWpa2Wpa3); 866 867 WifiConfiguration pskConfig = new WifiConfiguration(); 868 pskConfig.SSID = "\"ssid\""; 869 pskConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 870 WifiConfiguration saeConfig = new WifiConfiguration(); 871 saeConfig.SSID = "\"ssid\""; 872 saeConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 873 874 ScanResult pskScan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 875 pskScan.capabilities = "PSK"; 876 ScanResult saeScan = buildScanResult("ssid", "bssid0", 0, TestUtils.BAD_RSSI); 877 saeScan.capabilities = "SAE"; 878 879 StandardWifiEntry entry = new StandardWifiEntry( 880 mMockInjector, mTestHandler, 881 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 882 Arrays.asList(pskConfig, saeConfig), Arrays.asList(pskScan, saeScan), 883 mMockWifiManager, false /* forSavedNetworksPage */); 884 885 assertThat(entry.getSecurityString(true /* concise */)) 886 .isEqualTo(wifiSecurityShortWpaWpa2Wpa3); 887 } 888 889 @Test testGetSecurityString_connected_getConnectionSecurityType()890 public void testGetSecurityString_connected_getConnectionSecurityType() { 891 final String wifiSecurityShortWpaWpa2 = "WPA/WPA2"; 892 final String wifiSecurityShortWpa3 = "WPA3"; 893 when(mMockContext.getString(R.string.wifitrackerlib_wifi_security_short_wpa_wpa2)) 894 .thenReturn(wifiSecurityShortWpaWpa2); 895 when(mMockContext.getString(R.string.wifitrackerlib_wifi_security_short_sae)) 896 .thenReturn(wifiSecurityShortWpa3); 897 898 WifiConfiguration pskConfig = new WifiConfiguration(); 899 pskConfig.networkId = 1; 900 pskConfig.SSID = "\"ssid\""; 901 pskConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 902 WifiConfiguration saeConfig = new WifiConfiguration(); 903 saeConfig.networkId = 1; 904 saeConfig.SSID = "\"ssid\""; 905 saeConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 906 907 ScanResult pskScan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 908 pskScan.capabilities = "PSK"; 909 ScanResult saeScan = buildScanResult("ssid", "bssid0", 0, TestUtils.BAD_RSSI); 910 saeScan.capabilities = "SAE"; 911 912 when(mMockWifiInfo.getNetworkId()).thenReturn(1); 913 when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI); 914 915 StandardWifiEntry entry = new StandardWifiEntry( 916 mMockInjector, mTestHandler, 917 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 918 Arrays.asList(pskConfig, saeConfig), Arrays.asList(pskScan, saeScan), 919 mMockWifiManager, false /* forSavedNetworksPage */); 920 921 when(mMockWifiInfo.getCurrentSecurityType()).thenReturn(SECURITY_TYPE_PSK); 922 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 923 924 // Both PSK and SAE in range, but connected to PSK so show PSK security string 925 assertThat(entry.getSecurityString(true /* concise */)) 926 .isEqualTo(wifiSecurityShortWpaWpa2); 927 928 when(mMockWifiInfo.getCurrentSecurityType()).thenReturn(SECURITY_TYPE_SAE); 929 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 930 931 // Both PSK and SAE in range, but connected to SAE so show SAE security string 932 assertThat(entry.getSecurityString(true /* concise */)) 933 .isEqualTo(wifiSecurityShortWpa3); 934 } 935 936 @Test testGetSecurityString_eapAndEapWpa3_getWpaWpa2Wpa3Enterprise()937 public void testGetSecurityString_eapAndEapWpa3_getWpaWpa2Wpa3Enterprise() { 938 final String wifiSecurityEapWpaWpa2Wpa3 = "WPA/WPA2/WPA3-Enterprise"; 939 when(mMockContext.getString(R.string.wifitrackerlib_wifi_security_short_eap_wpa_wpa2_wpa3)) 940 .thenReturn(wifiSecurityEapWpaWpa2Wpa3); 941 942 WifiConfiguration eapConfig = new WifiConfiguration(); 943 eapConfig.SSID = "\"ssid\""; 944 eapConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 945 WifiConfiguration eapWpa3Config = new WifiConfiguration(); 946 eapWpa3Config.SSID = "\"ssid\""; 947 eapWpa3Config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 948 949 final ScanResult eapScan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 950 eapScan.capabilities = "[RSN-EAP/SHA1]"; 951 final ScanResult eapWpa3Scan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI); 952 eapWpa3Scan.capabilities = "[RSN-EAP/SHA256][MFPR][MFPC]"; 953 954 StandardWifiEntry entry = new StandardWifiEntry( 955 mMockInjector, mTestHandler, 956 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 957 Arrays.asList(eapConfig, eapWpa3Config), Arrays.asList(eapScan, eapWpa3Scan), 958 mMockWifiManager, false /* forSavedNetworksPage */); 959 960 assertThat(entry.getSecurityString(true /* concise */)) 961 .isEqualTo(wifiSecurityEapWpaWpa2Wpa3); 962 } 963 964 @Test testGetMeteredChoice_afterSetMeteredChoice_getCorrectValue()965 public void testGetMeteredChoice_afterSetMeteredChoice_getCorrectValue() { 966 StandardWifiEntry entry = 967 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 968 WifiConfiguration oldConfig = new WifiConfiguration(entry.getWifiConfiguration()); 969 assertThat(oldConfig.meteredOverride).isEqualTo(WifiConfiguration.METERED_OVERRIDE_NONE); 970 // Simulate the privacy being updated by someone else, but we haven't gotten the 971 // CONFIGURED_NETWORKS_CHANGED broadcast yet. 972 assertThat(oldConfig.macRandomizationSetting).isEqualTo( 973 WifiConfiguration.RANDOMIZATION_AUTO); 974 oldConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 975 when(mMockWifiManager.getPrivilegedConfiguredNetworks()) 976 .thenReturn(Collections.singletonList(oldConfig)); 977 978 entry.setMeteredChoice(WifiEntry.METERED_CHOICE_METERED); 979 980 assertThat(entry.getMeteredChoice()).isEqualTo(WifiEntry.METERED_CHOICE_METERED); 981 ArgumentCaptor<WifiConfiguration> configCaptor = 982 ArgumentCaptor.forClass(WifiConfiguration.class); 983 verify(mMockWifiManager).save(configCaptor.capture(), any()); 984 // Metered choice value should be updated. 985 assertThat(configCaptor.getValue().meteredOverride) 986 .isEqualTo(WifiConfiguration.METERED_OVERRIDE_METERED); 987 // Privacy value should not be overwritten by our stale config. 988 assertThat(configCaptor.getValue().macRandomizationSetting) 989 .isEqualTo(WifiConfiguration.RANDOMIZATION_NONE); 990 } 991 992 @Test testGetPrivacy_afterSetPrivacy_getCorrectValue()993 public void testGetPrivacy_afterSetPrivacy_getCorrectValue() { 994 StandardWifiEntry entry = 995 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 996 WifiConfiguration oldConfig = new WifiConfiguration(entry.getWifiConfiguration()); 997 assertThat(oldConfig.macRandomizationSetting).isEqualTo( 998 WifiConfiguration.RANDOMIZATION_AUTO); 999 // Simulate the metered choice being updated by someone else, but we haven't gotten the 1000 // CONFIGURED_NETWORKS_CHANGED broadcast yet. 1001 assertThat(oldConfig.meteredOverride).isEqualTo(WifiConfiguration.METERED_OVERRIDE_NONE); 1002 oldConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED; 1003 when(mMockWifiManager.getPrivilegedConfiguredNetworks()) 1004 .thenReturn(Collections.singletonList(oldConfig)); 1005 1006 entry.setPrivacy(WifiEntry.PRIVACY_DEVICE_MAC); 1007 1008 assertThat(entry.getMeteredChoice()).isEqualTo(WifiEntry.METERED_CHOICE_METERED); 1009 ArgumentCaptor<WifiConfiguration> configCaptor = 1010 ArgumentCaptor.forClass(WifiConfiguration.class); 1011 verify(mMockWifiManager).save(configCaptor.capture(), any()); 1012 // Privacy choice value should be updated. 1013 assertThat(configCaptor.getValue().macRandomizationSetting) 1014 .isEqualTo(WifiConfiguration.RANDOMIZATION_NONE); 1015 // Metered choice value should not be overwritten by our stale config. 1016 assertThat(configCaptor.getValue().meteredOverride) 1017 .isEqualTo(WifiConfiguration.METERED_OVERRIDE_METERED); 1018 } 1019 1020 1021 @Test testCanSignIn_captivePortalCapability_returnsTrue()1022 public void testCanSignIn_captivePortalCapability_returnsTrue() { 1023 WifiConfiguration wifiConfig = new WifiConfiguration(); 1024 wifiConfig.SSID = "\"ssid\""; 1025 wifiConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1026 wifiConfig.networkId = 1; 1027 when(mMockWifiInfo.getNetworkId()).thenReturn(wifiConfig.networkId); 1028 1029 when(mMockNetworkCapabilities.hasCapability( 1030 NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL)).thenReturn(true); 1031 StandardWifiEntry entry = new StandardWifiEntry( 1032 mMockInjector, mTestHandler, 1033 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 1034 Collections.singletonList(wifiConfig), null, mMockWifiManager, 1035 false /* forSavedNetworksPage */); 1036 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 1037 1038 assertThat(entry.canSignIn()).isTrue(); 1039 } 1040 1041 @Test testUpdateNetworkCapabilities_userConnect_autoOpenCaptivePortalOnce()1042 public void testUpdateNetworkCapabilities_userConnect_autoOpenCaptivePortalOnce() { 1043 WifiConfiguration wifiConfig = new WifiConfiguration(); 1044 wifiConfig.SSID = "\"ssid\""; 1045 wifiConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1046 wifiConfig.networkId = 1; 1047 when(mMockWifiInfo.getNetworkId()).thenReturn(wifiConfig.networkId); 1048 1049 when(mMockNetworkCapabilities.hasCapability( 1050 NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL)).thenReturn(true); 1051 StandardWifiEntry entry = new StandardWifiEntry( 1052 mMockInjector, mTestHandler, 1053 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 1054 Collections.singletonList(wifiConfig), null, mMockWifiManager, 1055 false /* forSavedNetworksPage */); 1056 1057 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 1058 try { 1059 // Simulate user tapping on the network and receiving captive portal capabilities. 1060 // This should trigger the captive portal app. 1061 entry.connect(null /* callback */); 1062 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 1063 1064 verify(() -> NonSdkApiWrapper.startCaptivePortalApp(any(), any()), times(1)); 1065 1066 // Update network capabilities again. This should not trigger the captive portal app. 1067 entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities); 1068 1069 verify(() -> NonSdkApiWrapper.startCaptivePortalApp(any(), any()), times(1)); 1070 } finally { 1071 session.finishMocking(); 1072 } 1073 } 1074 1075 @Test testShouldEditBeforeConnect_nullWifiConfig_returnFalse()1076 public void testShouldEditBeforeConnect_nullWifiConfig_returnFalse() { 1077 StandardWifiEntry entry = new StandardWifiEntry( 1078 mMockInjector, mTestHandler, 1079 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 1080 mMockWifiManager, false /* forSavedNetworksPage */); 1081 1082 assertThat(entry.shouldEditBeforeConnect()).isFalse(); 1083 } 1084 1085 @Test testShouldEditBeforeConnect_openNetwork_returnFalse()1086 public void testShouldEditBeforeConnect_openNetwork_returnFalse() { 1087 // Test open networks. 1088 WifiConfiguration wifiConfig = new WifiConfiguration(); 1089 wifiConfig.SSID = "\"ssid\""; 1090 wifiConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1091 StandardWifiEntry entry = new StandardWifiEntry( 1092 mMockInjector, mTestHandler, 1093 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 1094 Collections.singletonList(wifiConfig), null, mMockWifiManager, 1095 false /* forSavedNetworksPage */); 1096 1097 assertThat(entry.shouldEditBeforeConnect()).isFalse(); 1098 1099 // Test enhanced open networks. 1100 wifiConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OWE); 1101 entry = new StandardWifiEntry( 1102 mMockInjector, mTestHandler, 1103 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OWE), 1104 Collections.singletonList(wifiConfig), null, mMockWifiManager, 1105 false /* forSavedNetworksPage */); 1106 1107 assertThat(entry.shouldEditBeforeConnect()).isFalse(); 1108 } 1109 1110 @Test testShouldEditBeforeConnect_authenticationFailure_returnTrue()1111 public void testShouldEditBeforeConnect_authenticationFailure_returnTrue() { 1112 WifiConfiguration wifiConfig = spy(new WifiConfiguration()); 1113 wifiConfig.SSID = "\"ssid\""; 1114 wifiConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1115 StandardWifiEntry entry = new StandardWifiEntry( 1116 mMockInjector, mTestHandler, 1117 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1118 Collections.singletonList(wifiConfig), null, mMockWifiManager, 1119 false /* forSavedNetworksPage */); 1120 NetworkSelectionStatus networkSelectionStatus = mock(NetworkSelectionStatus.class); 1121 when(wifiConfig.getNetworkSelectionStatus()).thenReturn(networkSelectionStatus); 1122 1123 String saved = "Saved"; 1124 when(mMockContext.getString(R.string.wifitrackerlib_wifi_disconnected)).thenReturn(saved); 1125 String separator = " / "; 1126 when(mMockContext.getString(R.string.wifitrackerlib_summary_separator)) 1127 .thenReturn(separator); 1128 String disabledPasswordFailure = "disabledPasswordFailure"; 1129 when(mMockContext.getString(R.string.wifitrackerlib_wifi_disabled_password_failure)) 1130 .thenReturn(disabledPasswordFailure); 1131 String checkPasswordTryAgain = "checkPasswordTryAgain"; 1132 when(mMockContext.getString(R.string.wifitrackerlib_wifi_check_password_try_again)) 1133 .thenReturn(checkPasswordTryAgain); 1134 1135 // Test DISABLED_AUTHENTICATION_FAILURE for never connected network 1136 when(networkSelectionStatus.hasEverConnected()).thenReturn(false); 1137 when(networkSelectionStatus.getNetworkSelectionStatus()) 1138 .thenReturn(NETWORK_SELECTION_ENABLED); 1139 when(networkSelectionStatus.getDisableReasonCounter(DISABLED_AUTHENTICATION_FAILURE)) 1140 .thenReturn(1); 1141 assertThat(entry.shouldEditBeforeConnect()).isTrue(); 1142 assertThat(entry.getSummary()).isEqualTo(saved + separator + disabledPasswordFailure); 1143 1144 // Test DISABLED_AUTHENTICATION_FAILURE for a previously connected network 1145 when(networkSelectionStatus.hasEverConnected()).thenReturn(true); 1146 when(networkSelectionStatus.getNetworkSelectionStatus()) 1147 .thenReturn(NETWORK_SELECTION_PERMANENTLY_DISABLED); 1148 when(networkSelectionStatus.getNetworkSelectionDisableReason()) 1149 .thenReturn(DISABLED_AUTHENTICATION_FAILURE); 1150 when(wifiConfig.hasNoInternetAccess()).thenReturn(false); 1151 assertThat(entry.shouldEditBeforeConnect()).isTrue(); 1152 assertThat(entry.getSummary()).isEqualTo(saved + separator + disabledPasswordFailure); 1153 1154 // Test DISABLED_CONSECUTIVE_FAILURES with some DISABLED_AUTHENTICATION_FAILURE 1155 when(networkSelectionStatus.hasEverConnected()).thenReturn(false); 1156 when(networkSelectionStatus.getNetworkSelectionStatus()) 1157 .thenReturn(NETWORK_SELECTION_PERMANENTLY_DISABLED); 1158 when(networkSelectionStatus.getNetworkSelectionDisableReason()) 1159 .thenReturn(DISABLED_CONSECUTIVE_FAILURES); 1160 when(networkSelectionStatus.getDisableReasonCounter(DISABLED_AUTHENTICATION_FAILURE)) 1161 .thenReturn(3); 1162 assertThat(entry.shouldEditBeforeConnect()).isTrue(); 1163 assertThat(entry.getSummary()).isEqualTo(saved + separator + disabledPasswordFailure); 1164 1165 // Test DISABLED_BY_WRONG_PASSWORD. 1166 when(networkSelectionStatus.hasEverConnected()).thenReturn(false); 1167 when(networkSelectionStatus.getNetworkSelectionStatus()) 1168 .thenReturn(NETWORK_SELECTION_PERMANENTLY_DISABLED); 1169 when(networkSelectionStatus.getNetworkSelectionDisableReason()) 1170 .thenReturn(DISABLED_BY_WRONG_PASSWORD); 1171 assertThat(entry.shouldEditBeforeConnect()).isTrue(); 1172 assertThat(entry.getSummary()).isEqualTo(saved + separator + checkPasswordTryAgain); 1173 1174 // Test DISABLED_AUTHENTICATION_NO_CREDENTIALS. 1175 when(networkSelectionStatus.hasEverConnected()).thenReturn(false); 1176 when(networkSelectionStatus.getNetworkSelectionStatus()) 1177 .thenReturn(NETWORK_SELECTION_PERMANENTLY_DISABLED); 1178 when(networkSelectionStatus.getNetworkSelectionDisableReason()) 1179 .thenReturn(DISABLED_AUTHENTICATION_NO_CREDENTIALS); 1180 assertThat(entry.shouldEditBeforeConnect()).isTrue(); 1181 assertThat(entry.getSummary()).isEqualTo(saved + separator + disabledPasswordFailure); 1182 } 1183 1184 @Test testCanConnect_nonEapMethod_returnTrueIfReachable()1185 public void testCanConnect_nonEapMethod_returnTrueIfReachable() { 1186 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1187 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1188 mMockInjector, mTestHandler, 1189 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN), 1190 null, Arrays.asList(buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI)), 1191 mMockWifiManager, false /* forSavedNetworksPage */)); 1192 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1193 1194 assertThat(spyEntry.canConnect()).isEqualTo(true); 1195 1196 scan.capabilities = "OWE"; 1197 spyEntry = spy(new StandardWifiEntry( 1198 mMockInjector, mTestHandler, 1199 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OWE), 1200 null, Collections.singletonList(scan), 1201 mMockWifiManager, false /* forSavedNetworksPage */)); 1202 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1203 1204 assertThat(spyEntry.canConnect()).isEqualTo(true); 1205 1206 scan.capabilities = "WEP"; 1207 spyEntry = spy(new StandardWifiEntry( 1208 mMockInjector, mTestHandler, 1209 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_WEP), 1210 null, Collections.singletonList(scan), 1211 mMockWifiManager, false /* forSavedNetworksPage */)); 1212 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1213 1214 assertThat(spyEntry.canConnect()).isEqualTo(true); 1215 1216 scan.capabilities = "PSK"; 1217 spyEntry = spy(new StandardWifiEntry( 1218 mMockInjector, mTestHandler, 1219 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1220 null, Collections.singletonList(scan), 1221 mMockWifiManager, false /* forSavedNetworksPage */)); 1222 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1223 1224 assertThat(spyEntry.canConnect()).isEqualTo(true); 1225 1226 scan.capabilities = "SAE"; 1227 spyEntry = spy(new StandardWifiEntry( 1228 mMockInjector, mTestHandler, 1229 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_SAE), 1230 null, Collections.singletonList(scan), 1231 mMockWifiManager, false /* forSavedNetworksPage */)); 1232 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1233 1234 assertThat(spyEntry.canConnect()).isEqualTo(true); 1235 } 1236 1237 @Test testCanConnect_nonSimMethod_returnTrueIfReachable()1238 public void testCanConnect_nonSimMethod_returnTrueIfReachable() { 1239 WifiConfiguration config = new WifiConfiguration(); 1240 config.SSID = "\"ssid\""; 1241 WifiEnterpriseConfig mockWifiEnterpriseConfig = mock(WifiEnterpriseConfig.class); 1242 when(mockWifiEnterpriseConfig.isAuthenticationSimBased()).thenReturn(false); 1243 config.enterpriseConfig = mockWifiEnterpriseConfig; 1244 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1245 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1246 scan.capabilities = "EAP/SHA1"; 1247 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1248 mMockInjector, mTestHandler, 1249 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 1250 Collections.singletonList(config), Collections.singletonList(scan), 1251 mMockWifiManager, false /* forSavedNetworksPage */)); 1252 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1253 1254 assertThat(spyEntry.canConnect()).isEqualTo(true); 1255 } 1256 1257 @Test testCanConnect_unknownCarrierId_returnTrueIfActiveSubscriptionAvailable()1258 public void testCanConnect_unknownCarrierId_returnTrueIfActiveSubscriptionAvailable() { 1259 WifiConfiguration config = new WifiConfiguration(); 1260 config.SSID = "\"ssid\""; 1261 config.carrierId = TelephonyManager.UNKNOWN_CARRIER_ID; 1262 WifiEnterpriseConfig mockWifiEnterpriseConfig = mock(WifiEnterpriseConfig.class); 1263 when(mockWifiEnterpriseConfig.isAuthenticationSimBased()).thenReturn(true); 1264 config.enterpriseConfig = mockWifiEnterpriseConfig; 1265 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1266 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1267 scan.capabilities = "EAP/SHA1"; 1268 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1269 mMockInjector, mTestHandler, 1270 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 1271 Collections.singletonList(config), Collections.singletonList(scan), 1272 mMockWifiManager, false /* forSavedNetworksPage */)); 1273 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1274 when(mSubscriptionManager.getActiveSubscriptionInfoList()) 1275 .thenReturn(Arrays.asList(mock(SubscriptionInfo.class))); 1276 1277 assertThat(spyEntry.canConnect()).isEqualTo(true); 1278 } 1279 1280 @Test testCanConnect_specifiedCarrierIdMatched_returnTrue()1281 public void testCanConnect_specifiedCarrierIdMatched_returnTrue() { 1282 WifiConfiguration config = new WifiConfiguration(); 1283 config.SSID = "\"ssid\""; 1284 int carrierId = 6; 1285 config.carrierId = carrierId; 1286 WifiEnterpriseConfig mockWifiEnterpriseConfig = mock(WifiEnterpriseConfig.class); 1287 when(mockWifiEnterpriseConfig.isAuthenticationSimBased()).thenReturn(true); 1288 config.enterpriseConfig = mockWifiEnterpriseConfig; 1289 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1290 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1291 scan.capabilities = "EAP/SHA1"; 1292 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1293 mMockInjector, mTestHandler, 1294 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 1295 Collections.singletonList(config), Collections.singletonList(scan), 1296 mMockWifiManager, false /* forSavedNetworksPage */)); 1297 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1298 SubscriptionInfo mockSubscriptionInfo = mock(SubscriptionInfo.class); 1299 when(mockSubscriptionInfo.getCarrierId()).thenReturn(carrierId); 1300 when(mSubscriptionManager.getActiveSubscriptionInfoList()) 1301 .thenReturn(Arrays.asList(mockSubscriptionInfo)); 1302 1303 assertThat(spyEntry.canConnect()).isEqualTo(true); 1304 } 1305 1306 @Test testCanConnect_specifiedCarrierIdNotMatched_returnFalse()1307 public void testCanConnect_specifiedCarrierIdNotMatched_returnFalse() { 1308 WifiConfiguration config = new WifiConfiguration(); 1309 config.SSID = "\"ssid\""; 1310 int specifiedCarrierId = 6; 1311 int simCarrierId = 7; 1312 config.carrierId = specifiedCarrierId; 1313 WifiEnterpriseConfig mockWifiEnterpriseConfig = mock(WifiEnterpriseConfig.class); 1314 when(mockWifiEnterpriseConfig.isAuthenticationSimBased()).thenReturn(true); 1315 config.enterpriseConfig = mockWifiEnterpriseConfig; 1316 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1317 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1318 scan.capabilities = "EAP/SHA1"; 1319 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1320 mMockInjector, mTestHandler, 1321 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP), 1322 Collections.singletonList(config), Collections.singletonList(scan), 1323 mMockWifiManager, false /* forSavedNetworksPage */)); 1324 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1325 SubscriptionInfo mockSubscriptionInfo = mock(SubscriptionInfo.class); 1326 when(mockSubscriptionInfo.getCarrierId()).thenReturn(simCarrierId); 1327 when(mSubscriptionManager.getActiveSubscriptionInfoList()) 1328 .thenReturn(Arrays.asList(mockSubscriptionInfo)); 1329 1330 assertThat(spyEntry.canConnect()).isEqualTo(false); 1331 } 1332 1333 @Test testCanConnect_allowlistRestriction_returnTrue()1334 public void testCanConnect_allowlistRestriction_returnTrue() { 1335 assumeTrue(BuildCompat.isAtLeastT()); 1336 WifiConfiguration config = new WifiConfiguration(); 1337 config.SSID = "\"ssid\""; 1338 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1339 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1340 scan.capabilities = "PSK"; 1341 WifiSsidPolicy policy = new WifiSsidPolicy( 1342 WifiSsidPolicy.WIFI_SSID_POLICY_TYPE_ALLOWLIST, 1343 new ArraySet<>(Arrays.asList( 1344 WifiSsid.fromBytes("ssid".getBytes(StandardCharsets.UTF_8))))); 1345 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 1346 try { 1347 when(NonSdkApiWrapper.getWifiSsidPolicy(mDevicePolicyManager)).thenReturn(policy); 1348 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1349 mMockInjector, mTestHandler, 1350 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1351 Collections.singletonList(config), Collections.singletonList(scan), 1352 mMockWifiManager, false /* forSavedNetworksPage */)); 1353 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1354 assertThat(spyEntry.canConnect()).isEqualTo(true); 1355 } finally { 1356 session.finishMocking(); 1357 } 1358 } 1359 1360 @Test testCanConnect_allowlistRestriction_returnFalse()1361 public void testCanConnect_allowlistRestriction_returnFalse() { 1362 assumeTrue(BuildCompat.isAtLeastT()); 1363 WifiConfiguration config = new WifiConfiguration(); 1364 config.SSID = "\"ssid\""; 1365 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1366 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1367 scan.capabilities = "PSK"; 1368 WifiSsidPolicy policy = new WifiSsidPolicy( 1369 WifiSsidPolicy.WIFI_SSID_POLICY_TYPE_ALLOWLIST, 1370 new ArraySet<>(Arrays.asList( 1371 WifiSsid.fromBytes("ssid2".getBytes(StandardCharsets.UTF_8))))); 1372 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 1373 try { 1374 when(NonSdkApiWrapper.getWifiSsidPolicy(mDevicePolicyManager)).thenReturn(policy); 1375 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1376 mMockInjector, mTestHandler, 1377 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1378 Collections.singletonList(config), Collections.singletonList(scan), 1379 mMockWifiManager, false /* forSavedNetworksPage */)); 1380 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1381 assertThat(spyEntry.canConnect()).isEqualTo(false); 1382 } finally { 1383 session.finishMocking(); 1384 } 1385 } 1386 1387 @Test testCanConnect_denylistRestriction_returnTrue()1388 public void testCanConnect_denylistRestriction_returnTrue() { 1389 assumeTrue(BuildCompat.isAtLeastT()); 1390 WifiConfiguration config = new WifiConfiguration(); 1391 config.SSID = "\"ssid\""; 1392 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1393 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1394 scan.capabilities = "PSK"; 1395 WifiSsidPolicy policy = new WifiSsidPolicy( 1396 WifiSsidPolicy.WIFI_SSID_POLICY_TYPE_DENYLIST, 1397 new ArraySet<>(Arrays.asList( 1398 WifiSsid.fromBytes("ssid2".getBytes(StandardCharsets.UTF_8))))); 1399 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 1400 try { 1401 when(NonSdkApiWrapper.getWifiSsidPolicy(mDevicePolicyManager)).thenReturn(policy); 1402 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1403 mMockInjector, mTestHandler, 1404 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1405 Collections.singletonList(config), Collections.singletonList(scan), 1406 mMockWifiManager, false /* forSavedNetworksPage */)); 1407 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1408 assertThat(spyEntry.canConnect()).isEqualTo(true); 1409 } finally { 1410 session.finishMocking(); 1411 } 1412 } 1413 1414 @Test testCanConnect_denylistRestriction_returnFalse()1415 public void testCanConnect_denylistRestriction_returnFalse() { 1416 assumeTrue(BuildCompat.isAtLeastT()); 1417 WifiConfiguration config = new WifiConfiguration(); 1418 config.SSID = "\"ssid\""; 1419 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1420 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1421 scan.capabilities = "PSK"; 1422 WifiSsidPolicy policy = new WifiSsidPolicy( 1423 WifiSsidPolicy.WIFI_SSID_POLICY_TYPE_DENYLIST, 1424 new ArraySet<>(Arrays.asList( 1425 WifiSsid.fromBytes("ssid".getBytes(StandardCharsets.UTF_8))))); 1426 MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking(); 1427 try { 1428 when(NonSdkApiWrapper.getWifiSsidPolicy(mDevicePolicyManager)).thenReturn(policy); 1429 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1430 mMockInjector, mTestHandler, 1431 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1432 Collections.singletonList(config), Collections.singletonList(scan), 1433 mMockWifiManager, false /* forSavedNetworksPage */)); 1434 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1435 assertThat(spyEntry.canConnect()).isEqualTo(false); 1436 } finally { 1437 session.finishMocking(); 1438 } 1439 } 1440 1441 @Test testCanConnect_userRestrictionSet_savedNetwork_returnTrue()1442 public void testCanConnect_userRestrictionSet_savedNetwork_returnTrue() { 1443 assumeTrue(BuildCompat.isAtLeastT()); 1444 WifiConfiguration config = new WifiConfiguration(); 1445 config.SSID = "\"ssid\""; 1446 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1447 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1448 scan.capabilities = "PSK"; 1449 when(mUserManager.hasUserRestriction( 1450 UserManager.DISALLOW_ADD_WIFI_CONFIG)).thenReturn(true); 1451 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1452 mMockInjector, mTestHandler, 1453 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1454 Collections.singletonList(config), Collections.singletonList(scan), 1455 mMockWifiManager, false /* forSavedNetworksPage */)); 1456 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1457 when(spyEntry.isSaved()).thenReturn(true); 1458 1459 assertThat(spyEntry.canConnect()).isEqualTo(true); 1460 } 1461 1462 @Test testCanConnect_userRestrictionSet_suggestionNetwork_returnTrue()1463 public void testCanConnect_userRestrictionSet_suggestionNetwork_returnTrue() { 1464 assumeTrue(BuildCompat.isAtLeastT()); 1465 WifiConfiguration config = new WifiConfiguration(); 1466 config.SSID = "\"ssid\""; 1467 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1468 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1469 scan.capabilities = "PSK"; 1470 when(mUserManager.hasUserRestriction( 1471 UserManager.DISALLOW_ADD_WIFI_CONFIG)).thenReturn(true); 1472 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1473 mMockInjector, mTestHandler, 1474 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1475 Collections.singletonList(config), Collections.singletonList(scan), 1476 mMockWifiManager, false /* forSavedNetworksPage */)); 1477 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1478 when(spyEntry.isSuggestion()).thenReturn(true); 1479 1480 assertThat(spyEntry.canConnect()).isEqualTo(true); 1481 } 1482 1483 @Test testCanConnect_UserRestrictionSet_returnFalse()1484 public void testCanConnect_UserRestrictionSet_returnFalse() { 1485 assumeTrue(BuildCompat.isAtLeastT()); 1486 WifiConfiguration config = new WifiConfiguration(); 1487 config.SSID = "\"ssid\""; 1488 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1489 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1490 scan.capabilities = "PSK"; 1491 when(mUserManager.hasUserRestriction( 1492 UserManager.DISALLOW_ADD_WIFI_CONFIG)).thenReturn(true); 1493 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1494 mMockInjector, mTestHandler, 1495 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1496 Collections.singletonList(config), Collections.singletonList(scan), 1497 mMockWifiManager, false /* forSavedNetworksPage */)); 1498 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1499 when(spyEntry.isSaved()).thenReturn(false); 1500 when(spyEntry.isSuggestion()).thenReturn(false); 1501 1502 assertThat(spyEntry.canConnect()).isEqualTo(false); 1503 } 1504 1505 @Test testCanConnect_SecurityTypeRestriction_returnTrue()1506 public void testCanConnect_SecurityTypeRestriction_returnTrue() { 1507 assumeTrue(BuildCompat.isAtLeastT()); 1508 WifiConfiguration config = new WifiConfiguration(); 1509 config.SSID = "\"ssid\""; 1510 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1511 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1512 scan.capabilities = "PSK"; 1513 when(mDevicePolicyManager.getMinimumRequiredWifiSecurityLevel()).thenReturn( 1514 DevicePolicyManager.WIFI_SECURITY_PERSONAL); 1515 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1516 mMockInjector, mTestHandler, 1517 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1518 Collections.singletonList(config), Collections.singletonList(scan), 1519 mMockWifiManager, false /* forSavedNetworksPage */)); 1520 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1521 1522 assertThat(spyEntry.canConnect()).isEqualTo(true); 1523 } 1524 1525 @Test testCanConnect_SecurityTypeRestriction_returnFalse()1526 public void testCanConnect_SecurityTypeRestriction_returnFalse() { 1527 assumeTrue(BuildCompat.isAtLeastT()); 1528 WifiConfiguration config = new WifiConfiguration(); 1529 config.SSID = "\"ssid\""; 1530 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1531 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1532 scan.capabilities = "PSK"; 1533 when(mDevicePolicyManager.getMinimumRequiredWifiSecurityLevel()).thenReturn( 1534 DevicePolicyManager.WIFI_SECURITY_ENTERPRISE_EAP); 1535 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1536 mMockInjector, mTestHandler, 1537 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1538 Collections.singletonList(config), Collections.singletonList(scan), 1539 mMockWifiManager, false /* forSavedNetworksPage */)); 1540 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1541 1542 assertThat(spyEntry.canConnect()).isEqualTo(false); 1543 } 1544 1545 @Test testStandardWifiEntryKeyConstructor_fromConfig_matchesFromScanResultKey()1546 public void testStandardWifiEntryKeyConstructor_fromConfig_matchesFromScanResultKey() { 1547 WifiConfiguration config = new WifiConfiguration(); 1548 config.SSID = "\"ssid\""; 1549 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1550 assertThat(new StandardWifiEntryKey(config, true /* isTargetingNewNetworks */)) 1551 .isEqualTo(new StandardWifiEntryKey( 1552 new ScanResultKey(config), true /* isTargetingNewNetworks */)); 1553 } 1554 1555 @Test testStandardWifiEntryKey_toAndFromJson_matches()1556 public void testStandardWifiEntryKey_toAndFromJson_matches() throws Exception { 1557 WifiConfiguration mockConfig = spy(new WifiConfiguration()); 1558 mockConfig.SSID = "\"ssid\""; 1559 when(mockConfig.getProfileKey()).thenReturn("profileKey"); 1560 mockConfig.fromWifiNetworkSpecifier = true; 1561 final StandardWifiEntryKey entryKey = new StandardWifiEntryKey( 1562 mockConfig, true /* isTargetingNewNetworks */); 1563 1564 assertThat(new StandardWifiEntryKey(entryKey.toString())).isEqualTo(entryKey); 1565 } 1566 1567 @Test testGetLevel_multipleSecurities_configAndScansMatch()1568 public void testGetLevel_multipleSecurities_configAndScansMatch() { 1569 WifiConfiguration pskConfig = new WifiConfiguration(); 1570 pskConfig.SSID = "\"ssid\""; 1571 pskConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1572 WifiConfiguration saeConfig = new WifiConfiguration(); 1573 saeConfig.SSID = "\"ssid\""; 1574 saeConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1575 1576 ScanResult pskScan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1577 pskScan.capabilities = "PSK"; 1578 ScanResult saeScan = buildScanResult("ssid", "bssid0", 0, TestUtils.BAD_RSSI); 1579 saeScan.capabilities = "SAE"; 1580 StandardWifiEntry entry = new StandardWifiEntry( 1581 mMockInjector, mTestHandler, 1582 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK, 1583 true /* isTargetingNewNetwork */), 1584 Collections.singletonList(pskConfig), Arrays.asList(pskScan, saeScan), 1585 mMockWifiManager, false /* forSavedNetworksPage */); 1586 1587 // Only PSK config, so use PSK scan level 1588 assertThat(entry.getLevel()).isEqualTo(TestUtils.GOOD_LEVEL); 1589 assertThat(entry.isSaved()).isTrue(); 1590 1591 entry.updateConfig(Collections.singletonList(saeConfig)); 1592 1593 // Only SAE config, so use SAE scan level 1594 assertThat(entry.getLevel()).isEqualTo(TestUtils.BAD_LEVEL); 1595 assertThat(entry.isSaved()).isTrue(); 1596 1597 entry.updateScanResultInfo(Collections.singletonList(pskScan)); 1598 1599 // SAE config and PSK scan do not match, so entry is unsaved with PSK scan level 1600 assertThat(entry.getLevel()).isEqualTo(TestUtils.GOOD_LEVEL); 1601 assertThat(entry.isSaved()).isFalse(); 1602 } 1603 1604 @Test testConnect_unsavedOpen_configuresOpenNetwork()1605 public void testConnect_unsavedOpen_configuresOpenNetwork() { 1606 ScanResult openScan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1607 openScan.capabilities = ""; 1608 StandardWifiEntry entry = new StandardWifiEntry( 1609 mMockInjector, mTestHandler, 1610 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN, 1611 true /* isTargetingNewNetworks */), 1612 null, Collections.singletonList(openScan), 1613 mMockWifiManager, false /* forSavedNetworksPage */); 1614 ArgumentCaptor<WifiConfiguration> connectConfigCaptor = 1615 ArgumentCaptor.forClass(WifiConfiguration.class); 1616 1617 entry.connect(null); 1618 verify(mMockWifiManager).connect(connectConfigCaptor.capture(), any()); 1619 1620 assertThat(Utils.getSecurityTypesFromWifiConfiguration(connectConfigCaptor.getValue())) 1621 .isEqualTo(Collections.singletonList(SECURITY_TYPE_OPEN)); 1622 } 1623 1624 @Test testConnect_unsavedOwe_configuresOweNetwork()1625 public void testConnect_unsavedOwe_configuresOweNetwork() { 1626 ScanResult oweScan = buildScanResult("ssid", "bssid0", 0, TestUtils.BAD_RSSI); 1627 oweScan.capabilities = "OWE"; 1628 StandardWifiEntry entry = new StandardWifiEntry( 1629 mMockInjector, mTestHandler, 1630 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OWE, 1631 true /* isTargetingNewNetworks */), 1632 null, Collections.singletonList(oweScan), 1633 mMockWifiManager, false /* forSavedNetworksPage */); 1634 ArgumentCaptor<WifiConfiguration> connectConfigCaptor = 1635 ArgumentCaptor.forClass(WifiConfiguration.class); 1636 1637 entry.connect(null); 1638 verify(mMockWifiManager).connect(connectConfigCaptor.capture(), any()); 1639 1640 assertThat(Utils.getSecurityTypesFromWifiConfiguration(connectConfigCaptor.getValue())) 1641 .isEqualTo(Collections.singletonList(SECURITY_TYPE_OWE)); 1642 } 1643 1644 @Test testConnect_unsavedOpenOwe_configuresOweAndOpenNetwork()1645 public void testConnect_unsavedOpenOwe_configuresOweAndOpenNetwork() { 1646 ScanResult oweTransitionScan = buildScanResult("ssid", "bssid0", 0, TestUtils.BAD_RSSI); 1647 oweTransitionScan.capabilities = "OWE_TRANSITION"; 1648 StandardWifiEntry entry = new StandardWifiEntry( 1649 mMockInjector, mTestHandler, 1650 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN, 1651 true /* isTargetingNewNetworks */), 1652 null, Collections.singletonList(oweTransitionScan), 1653 mMockWifiManager, false /* forSavedNetworksPage */); 1654 ArgumentCaptor<WifiConfiguration> connectConfigCaptor = 1655 ArgumentCaptor.forClass(WifiConfiguration.class); 1656 ArgumentCaptor<WifiConfiguration> savedConfigCaptor = 1657 ArgumentCaptor.forClass(WifiConfiguration.class); 1658 1659 entry.connect(null); 1660 verify(mMockWifiManager).connect(connectConfigCaptor.capture(), any()); 1661 verify(mMockWifiManager).save(savedConfigCaptor.capture(), any()); 1662 1663 assertThat(Utils.getSecurityTypesFromWifiConfiguration(connectConfigCaptor.getValue())) 1664 .isEqualTo(Collections.singletonList(SECURITY_TYPE_OWE)); 1665 assertThat(Utils.getSecurityTypesFromWifiConfiguration(savedConfigCaptor.getValue())) 1666 .isEqualTo(Collections.singletonList(SECURITY_TYPE_OPEN)); 1667 } 1668 1669 @Test testGetSecurity_openAndOwe_returnsOpen()1670 public void testGetSecurity_openAndOwe_returnsOpen() { 1671 WifiConfiguration openConfig = new WifiConfiguration(); 1672 openConfig.SSID = "\"ssid\""; 1673 openConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1674 WifiConfiguration oweConfig = new WifiConfiguration(); 1675 oweConfig.SSID = "\"ssid\""; 1676 oweConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OWE); 1677 1678 StandardWifiEntry entry = new StandardWifiEntry( 1679 mMockInjector, mTestHandler, 1680 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_OPEN, 1681 true /* isTargetingNewNetwork */), 1682 Arrays.asList(openConfig, oweConfig), null, 1683 mMockWifiManager, false /* forSavedNetworksPage */); 1684 1685 assertThat(entry.getSecurity()).isEqualTo(WifiEntry.SECURITY_NONE); 1686 assertThat(entry.getWifiConfiguration()).isEqualTo(openConfig); 1687 } 1688 1689 @Test testGetSecurity_pskAndSae_returnsPsk()1690 public void testGetSecurity_pskAndSae_returnsPsk() { 1691 WifiConfiguration pskConfig = new WifiConfiguration(); 1692 pskConfig.SSID = "\"ssid\""; 1693 pskConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1694 WifiConfiguration saeConfig = new WifiConfiguration(); 1695 saeConfig.SSID = "\"ssid\""; 1696 saeConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1697 1698 StandardWifiEntry entry = new StandardWifiEntry( 1699 mMockInjector, mTestHandler, 1700 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK, 1701 true /* isTargetingNewNetwork */), 1702 Arrays.asList(pskConfig, saeConfig), null, 1703 mMockWifiManager, false /* forSavedNetworksPage */); 1704 1705 assertThat(entry.getSecurity()).isEqualTo(WifiEntry.SECURITY_PSK); 1706 assertThat(entry.getWifiConfiguration()).isEqualTo(pskConfig); 1707 } 1708 1709 @Test testGetSecurity_eapAndEapWpa3_returnsEap()1710 public void testGetSecurity_eapAndEapWpa3_returnsEap() { 1711 WifiConfiguration eapConfig = new WifiConfiguration(); 1712 eapConfig.SSID = "\"ssid\""; 1713 eapConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1714 WifiConfiguration eapWpa3Config = new WifiConfiguration(); 1715 eapWpa3Config.SSID = "\"ssid\""; 1716 eapWpa3Config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 1717 1718 StandardWifiEntry entry = new StandardWifiEntry( 1719 mMockInjector, mTestHandler, 1720 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP, 1721 true /* isTargetingNewNetwork */), 1722 Arrays.asList(eapConfig, eapWpa3Config), null, 1723 mMockWifiManager, false /* forSavedNetworksPage */); 1724 1725 assertThat(entry.getSecurity()).isEqualTo(WifiEntry.SECURITY_EAP); 1726 assertThat(entry.getWifiConfiguration()).isEqualTo(eapConfig); 1727 } 1728 1729 @Test testCanShare_isDemoMode_returnsFalse()1730 public void testCanShare_isDemoMode_returnsFalse() { 1731 when(mMockInjector.isDemoMode()).thenReturn(true); 1732 1733 final StandardWifiEntry pskWifiEntry = 1734 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 1735 1736 assertThat(pskWifiEntry.canShare()).isFalse(); 1737 } 1738 1739 @Test testCanEasyConnect_isDemoMode_returnsFalse()1740 public void testCanEasyConnect_isDemoMode_returnsFalse() { 1741 when(mMockInjector.isDemoMode()).thenReturn(true); 1742 1743 final StandardWifiEntry pskWifiEntry = 1744 getSavedStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 1745 1746 assertThat(pskWifiEntry.canEasyConnect()).isFalse(); 1747 } 1748 1749 @Test testCanShare_UserRestrictionSet_returnsFalse()1750 public void testCanShare_UserRestrictionSet_returnsFalse() { 1751 assumeTrue(BuildCompat.isAtLeastT()); 1752 when(mMockInjector.isDemoMode()).thenReturn(false); 1753 when(mUserManager.hasUserRestrictionForUser( 1754 eq(UserManager.DISALLOW_SHARING_ADMIN_CONFIGURED_WIFI), any())).thenReturn(true); 1755 when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser()) 1756 .thenReturn(new ComponentName(TEST_PACKAGE_NAME, new String())); 1757 when(mDevicePolicyManager.getDeviceOwnerUser()) 1758 .thenReturn(UserHandle.getUserHandleForUid(MANAGED_PROFILE_UID)); 1759 1760 final StandardWifiEntry pskWifiEntry = 1761 getSavedDOStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 1762 1763 assertThat(pskWifiEntry.canShare()).isFalse(); 1764 } 1765 1766 @Test testCanEasyConnect_UserRestrictionSet_returnsFalse()1767 public void testCanEasyConnect_UserRestrictionSet_returnsFalse() { 1768 assumeTrue(BuildCompat.isAtLeastT()); 1769 when(mMockInjector.isDemoMode()).thenReturn(false); 1770 when(mUserManager.hasUserRestrictionForUser( 1771 eq(UserManager.DISALLOW_SHARING_ADMIN_CONFIGURED_WIFI), any())).thenReturn(true); 1772 when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser()) 1773 .thenReturn(new ComponentName(TEST_PACKAGE_NAME, new String())); 1774 when(mDevicePolicyManager.getDeviceOwnerUser()) 1775 .thenReturn(UserHandle.getUserHandleForUid(MANAGED_PROFILE_UID)); 1776 1777 final StandardWifiEntry pskWifiEntry = 1778 getSavedDOStandardWifiEntry(WifiConfiguration.SECURITY_TYPE_PSK); 1779 1780 assertThat(pskWifiEntry.canEasyConnect()).isFalse(); 1781 } 1782 1783 @Test testHasAdminRestrictions_noUserRestrictionSet_returnsFalse()1784 public void testHasAdminRestrictions_noUserRestrictionSet_returnsFalse() { 1785 assumeTrue(BuildCompat.isAtLeastT()); 1786 WifiConfiguration config = new WifiConfiguration(); 1787 config.SSID = "\"ssid\""; 1788 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1789 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1790 scan.capabilities = "PSK"; 1791 when(mUserManager.hasUserRestriction( 1792 UserManager.DISALLOW_ADD_WIFI_CONFIG)).thenReturn(false); 1793 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1794 mMockInjector, mTestHandler, 1795 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1796 Collections.singletonList(config), Collections.singletonList(scan), 1797 mMockWifiManager, false /* forSavedNetworksPage */)); 1798 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1799 when(spyEntry.isSaved()).thenReturn(false); 1800 when(spyEntry.isSuggestion()).thenReturn(false); 1801 1802 assertThat(spyEntry.hasAdminRestrictions()).isEqualTo(false); 1803 } 1804 1805 @Test testHasAdminRestrictions_userRestrictionSet_returnsTrue()1806 public void testHasAdminRestrictions_userRestrictionSet_returnsTrue() { 1807 assumeTrue(BuildCompat.isAtLeastT()); 1808 WifiConfiguration config = new WifiConfiguration(); 1809 config.SSID = "\"ssid\""; 1810 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1811 ScanResult scan = buildScanResult("ssid", "bssid0", 0, TestUtils.GOOD_RSSI); 1812 scan.capabilities = "PSK"; 1813 when(mUserManager.hasUserRestriction( 1814 UserManager.DISALLOW_ADD_WIFI_CONFIG)).thenReturn(true); 1815 StandardWifiEntry spyEntry = spy(new StandardWifiEntry( 1816 mMockInjector, mTestHandler, 1817 ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_PSK), 1818 Collections.singletonList(config), Collections.singletonList(scan), 1819 mMockWifiManager, false /* forSavedNetworksPage */)); 1820 when(spyEntry.getConnectedState()).thenReturn(CONNECTED_STATE_DISCONNECTED); 1821 when(spyEntry.isSaved()).thenReturn(false); 1822 when(spyEntry.isSuggestion()).thenReturn(false); 1823 1824 assertThat(spyEntry.hasAdminRestrictions()).isEqualTo(true); 1825 } 1826 } 1827