tests/robotests/src/com/android/settings/wifi/details/WifiDetailPreferenceControllerTest.java

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.android.settings.wifi.details;
  17
  18 import static com.google.common.truth.Truth.assertThat;
  19
  20 import static org.mockito.Matchers.any;
  21 import static org.mockito.Mockito.doNothing;
  22 import static org.mockito.Mockito.inOrder;
  23 import static org.mockito.Mockito.never;
  24 import static org.mockito.Mockito.reset;
  25 import static org.mockito.Mockito.times;
  26 import static org.mockito.Mockito.verify;
  27 import static org.mockito.Mockito.when;
  28
  29 import android.app.Activity;
  30 import android.content.Context;
  31 import android.content.Intent;
  32 import android.graphics.drawable.Drawable;
  33 import android.net.ConnectivityManager;
  34 import android.net.ConnectivityManager.NetworkCallback;
  35 import android.net.IpPrefix;
  36 import android.net.LinkAddress;
  37 import android.net.LinkProperties;
  38 import android.net.Network;
  39 import android.net.NetworkBadging;
  40 import android.net.NetworkCapabilities;
  41 import android.net.NetworkInfo;
  42 import android.net.NetworkRequest;
  43 import android.net.RouteInfo;
  44 import android.net.wifi.WifiConfiguration;
  45 import android.net.wifi.WifiInfo;
  46 import android.net.wifi.WifiManager;
  47 import android.os.Handler;
  48 import android.support.v7.preference.Preference;
  49 import android.support.v7.preference.PreferenceCategory;
  50 import android.support.v7.preference.PreferenceScreen;
  51 import android.view.View;
  52 import android.view.View.OnClickListener;
  53 import android.widget.Button;
  54
  55 import com.android.internal.logging.nano.MetricsProto;
  56 import com.android.settings.R;
  57 import com.android.settings.SettingsRobolectricTestRunner;
  58 import com.android.settings.TestConfig;
  59 import com.android.settings.applications.LayoutPreference;
  60 import com.android.settings.core.instrumentation.MetricsFeatureProvider;
  61 import com.android.settings.core.lifecycle.Lifecycle;
  62 import com.android.settings.vpn2.ConnectivityManagerWrapperImpl;
  63 import com.android.settings.wifi.WifiDetailPreference;
  64 import com.android.settingslib.wifi.AccessPoint;
  65
  66 import org.junit.Before;
  67 import org.junit.Test;
  68 import org.junit.runner.RunWith;
  69 import org.mockito.Answers;
  70 import org.mockito.ArgumentCaptor;
  71 import org.mockito.Captor;
  72 import org.mockito.InOrder;
  73 import org.mockito.Mock;
  74 import org.mockito.MockitoAnnotations;
  75 import org.robolectric.RuntimeEnvironment;
  76 import org.robolectric.annotation.Config;
  77
  78 import java.net.Inet4Address;
  79 import java.net.Inet6Address;
  80 import java.net.InetAddress;
  81 import java.net.UnknownHostException;
  82 import java.util.Arrays;
  83 import java.util.List;
  84 import java.util.stream.Collectors;
  85
  86 @RunWith(SettingsRobolectricTestRunner.class)
  87 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
  88 public class WifiDetailPreferenceControllerTest {
  89
  90     private static final int LEVEL = 1;
  91     private static final int RSSI = -55;
  92     private static final int LINK_SPEED = 123;
  93     private static final String MAC_ADDRESS = WifiInfo.DEFAULT_MAC_ADDRESS;
  94     private static final String SECURITY = "None";
  95
  96     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
  97     private PreferenceScreen mockScreen;
  98
  99     @Mock private AccessPoint mockAccessPoint;
 100     @Mock private Activity mockActivity;
 101     @Mock private ConnectivityManager mockConnectivityManager;
 102     @Mock private ConnectivityManagerWrapperImpl mockConnectivityManagerWrapper;
 103     @Mock private Network mockNetwork;
 104     @Mock private NetworkInfo mockNetworkInfo;
 105     @Mock private WifiConfiguration mockWifiConfig;
 106     @Mock private WifiInfo mockWifiInfo;
 107     @Mock private WifiNetworkDetailsFragment mockFragment;
 108     @Mock private WifiManager mockWifiManager;
 109     @Mock private MetricsFeatureProvider mockMetricsFeatureProvider;
 110
 111     @Mock private Preference mockConnectionDetailPref;
 112     @Mock private LayoutPreference mockButtonsPref;
 113     @Mock private Button mockSignInButton;
 114     @Mock private WifiDetailPreference mockSignalStrengthPref;
 115     @Mock private WifiDetailPreference mockLinkSpeedPref;
 116     @Mock private WifiDetailPreference mockFrequencyPref;
 117     @Mock private WifiDetailPreference mockSecurityPref;
 118     @Mock private WifiDetailPreference mockMacAddressPref;
 119     @Mock private WifiDetailPreference mockIpAddressPref;
 120     @Mock private WifiDetailPreference mockGatewayPref;
 121     @Mock private WifiDetailPreference mockSubnetPref;
 122     @Mock private WifiDetailPreference mockDnsPref;
 123     @Mock private Button mockForgetButton;
 124     @Mock private PreferenceCategory mockIpv6Category;
 125     @Mock private WifiDetailPreference mockIpv6AddressesPref;
 126
 127     @Captor private ArgumentCaptor<NetworkCallback> mCallbackCaptor;
 128     @Captor private ArgumentCaptor<View.OnClickListener> mForgetClickListener;
 129     @Captor private ArgumentCaptor<Preference> mIpv6AddressCaptor;
 130
 131     private Context mContext = RuntimeEnvironment.application;
 132     private Lifecycle mLifecycle;
 133     private LinkProperties mLinkProperties;
 134     private WifiDetailPreferenceController mController;
 135
 136     // This class exists so that these values can be made static final. They can't be static final
 137     // members of the test class, because any attempt to call IpPrefix or RouteInfo constructors
 138     // during static initialization of the test class results in NoSuchMethorError being thrown
 139     // when the test is run.
 140     private static class Constants {
 141         static final int IPV4_PREFIXLEN = 25;
 142         static final LinkAddress IPV4_ADDR;
 143         static final Inet4Address IPV4_GATEWAY;
 144         static final RouteInfo IPV4_DEFAULT;
 145         static final RouteInfo IPV4_SUBNET;
 146         static final LinkAddress IPV6_LINKLOCAL;
 147         static final LinkAddress IPV6_GLOBAL1;
 148         static final LinkAddress IPV6_GLOBAL2;
 149         static final InetAddress IPV4_DNS1;
 150         static final InetAddress IPV4_DNS2;
 151         static final InetAddress IPV6_DNS;
 152
 153         private static LinkAddress ipv6LinkAddress(String addr) throws UnknownHostException {
 154             return new LinkAddress(InetAddress.getByName(addr), 64);
 155         }
 156
 157         private static LinkAddress ipv4LinkAddress(String addr, int prefixlen)
 158                 throws UnknownHostException {
 159             return new LinkAddress(InetAddress.getByName(addr), prefixlen);
 160         }
 161
 162         static {
 163             try {
 164                 // We create our test constants in these roundabout ways because the robolectric
 165                 // shadows don't contain NetworkUtils.parseNumericAddress and other utility methods,
 166                 // so the easy ways to do things fail with NoSuchMethodError.
 167                 IPV4_ADDR = ipv4LinkAddress("192.0.2.2", IPV4_PREFIXLEN);
 168                 IPV4_GATEWAY = (Inet4Address) InetAddress.getByName("192.0.2.127");
 169
 170                 final Inet4Address any4 = (Inet4Address) InetAddress.getByName("0.0.0.0");
 171                 IpPrefix subnet = new IpPrefix(IPV4_ADDR.getAddress(), IPV4_PREFIXLEN);
 172                 IPV4_SUBNET = new RouteInfo(subnet, any4);
 173                 IPV4_DEFAULT = new RouteInfo(new IpPrefix(any4, 0), IPV4_GATEWAY);
 174
 175                 IPV6_LINKLOCAL = ipv6LinkAddress("fe80::211:25ff:fef8:7cb2%1");
 176                 IPV6_GLOBAL1 = ipv6LinkAddress("2001:db8:1::211:25ff:fef8:7cb2");
 177                 IPV6_GLOBAL2 = ipv6LinkAddress("2001:db8:1::3dfe:8902:f98f:739d");
 178
 179                 IPV4_DNS1 = InetAddress.getByName("8.8.8.8");
 180                 IPV4_DNS2 = InetAddress.getByName("8.8.4.4");
 181                 IPV6_DNS = InetAddress.getByName("2001:4860:4860::64");
 182             } catch (UnknownHostException e) {
 183                 throw new RuntimeException("Invalid hardcoded IP addresss: " + e);
 184             }
 185         }
 186     }
 187
 188     @Before
 189     public void setUp() {
 190         MockitoAnnotations.initMocks(this);
 191
 192         mLifecycle = new Lifecycle();
 193
 194         when(mockAccessPoint.getConfig()).thenReturn(mockWifiConfig);
 195         when(mockAccessPoint.getLevel()).thenReturn(LEVEL);
 196         when(mockAccessPoint.getSecurityString(false)).thenReturn(SECURITY);
 197
 198         when(mockConnectivityManagerWrapper.getConnectivityManager())
 199                 .thenReturn(mockConnectivityManager);
 200         when(mockConnectivityManager.getNetworkInfo(any(Network.class)))
 201                 .thenReturn(mockNetworkInfo);
 202         doNothing().when(mockConnectivityManagerWrapper).registerNetworkCallback(
 203                 any(NetworkRequest.class), mCallbackCaptor.capture(), any(Handler.class));
 204         doNothing().when(mockForgetButton).setOnClickListener(mForgetClickListener.capture());
 205
 206         when(mockWifiInfo.getLinkSpeed()).thenReturn(LINK_SPEED);
 207         when(mockWifiInfo.getRssi()).thenReturn(RSSI);
 208         when(mockWifiInfo.getMacAddress()).thenReturn(MAC_ADDRESS);
 209         when(mockWifiManager.getConnectionInfo()).thenReturn(mockWifiInfo);
 210
 211         when(mockWifiManager.getCurrentNetwork()).thenReturn(mockNetwork);
 212         mLinkProperties = new LinkProperties();
 213         when(mockConnectivityManager.getLinkProperties(mockNetwork)).thenReturn(mLinkProperties);
 214
 215         when(mockFragment.getActivity()).thenReturn(mockActivity);
 216
 217         setupMockedPreferenceScreen();
 218         mController = newWifiDetailPreferenceController();
 219     }
 220
 221     private WifiDetailPreferenceController newWifiDetailPreferenceController() {
 222         return new WifiDetailPreferenceController(
 223                 mockAccessPoint,
 224                 mockConnectivityManagerWrapper,
 225                 mContext,
 226                 mockFragment,
 227                 null,  // Handler
 228                 mLifecycle,
 229                 mockWifiManager,
 230                 mockMetricsFeatureProvider);
 231     }
 232
 233     private void setupMockedPreferenceScreen() {
 234         when(mockScreen.getPreferenceManager().getContext()).thenReturn(mContext);
 235
 236         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_CONNECTION_DETAIL_PREF))
 237                 .thenReturn(mockConnectionDetailPref);
 238         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_BUTTONS_PREF))
 239                 .thenReturn(mockButtonsPref);
 240         when(mockButtonsPref.findViewById(R.id.forget_button))
 241                 .thenReturn(mockForgetButton);
 242         when(mockButtonsPref.findViewById(R.id.signin_button))
 243                 .thenReturn(mockSignInButton);
 244         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_SIGNAL_STRENGTH_PREF))
 245                 .thenReturn(mockSignalStrengthPref);
 246         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_LINK_SPEED))
 247                 .thenReturn(mockLinkSpeedPref);
 248         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_FREQUENCY_PREF))
 249                 .thenReturn(mockFrequencyPref);
 250         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_SECURITY_PREF))
 251                 .thenReturn(mockSecurityPref);
 252         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_MAC_ADDRESS_PREF))
 253                 .thenReturn(mockMacAddressPref);
 254         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_IP_ADDRESS_PREF))
 255                 .thenReturn(mockIpAddressPref);
 256         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_GATEWAY_PREF))
 257                 .thenReturn(mockGatewayPref);
 258         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_SUBNET_MASK_PREF))
 259                 .thenReturn(mockSubnetPref);
 260         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_DNS_PREF))
 261                 .thenReturn(mockDnsPref);
 262         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_IPV6_CATEGORY))
 263                 .thenReturn(mockIpv6Category);
 264         when(mockScreen.findPreference(WifiDetailPreferenceController.KEY_IPV6_ADDRESSES_PREF))
 265                 .thenReturn(mockIpv6AddressesPref);
 266     }
 267
 268     @Test
 269     public void isAvailable_shouldAlwaysReturnTrue() {
 270         mController.displayPreference(mockScreen);
 271
 272         assertThat(mController.isAvailable()).isTrue();
 273     }
 274
 275     @Test
 276     public void securityPreference_stringShouldBeSet() {
 277         mController.displayPreference(mockScreen);
 278
 279         verify(mockSecurityPref).setDetailText(SECURITY);
 280     }
 281
 282     @Test
 283     public void latestWifiInfo_shouldBeFetchedInDisplayPreference() {
 284         mController.displayPreference(mockScreen);
 285
 286         verify(mockWifiManager, times(1)).getConnectionInfo();
 287     }
 288
 289     @Test
 290     public void latestNetworkInfo_shouldBeFetchedInDisplayPreference() {
 291         mController.displayPreference(mockScreen);
 292
 293         verify(mockConnectivityManager, times(1)).getNetworkInfo(any(Network.class));
 294     }
 295
 296     @Test
 297     public void networkCallback_shouldBeRegisteredOnResume() {
 298         mController.onResume();
 299
 300         verify(mockConnectivityManagerWrapper, times(1)).registerNetworkCallback(
 301                 any(NetworkRequest.class), mCallbackCaptor.capture(), any(Handler.class));
 302     }
 303
 304     @Test
 305     public void networkCallback_shouldBeUnregisteredOnPause() {
 306         mController.onResume();
 307         mController.onPause();
 308
 309         verify(mockConnectivityManager, times(1)).unregisterNetworkCallback(
 310                 mCallbackCaptor.getValue());
 311     }
 312
 313     @Test
 314     public void connectionDetailPref_shouldHaveIconSet() {
 315         Drawable expectedIcon =
 316                 NetworkBadging.getWifiIcon(LEVEL, NetworkBadging.BADGING_NONE, mContext.getTheme());
 317
 318         mController.displayPreference(mockScreen);
 319
 320         verify(mockConnectionDetailPref).setIcon(expectedIcon);
 321     }
 322
 323     @Test
 324     public void connectionDetailPref_shouldHaveTitleSet() {
 325         String summary = "summary";
 326         when(mockAccessPoint.getSettingsSummary()).thenReturn(summary);
 327
 328         mController.displayPreference(mockScreen);
 329
 330         verify(mockConnectionDetailPref).setTitle(summary);
 331     }
 332
 333     @Test
 334     public void signalStrengthPref_shouldHaveIconSet() {
 335         mController.displayPreference(mockScreen);
 336
 337         verify(mockSignalStrengthPref).setIcon(any(Drawable.class));
 338     }
 339
 340     @Test
 341     public void signalStrengthPref_shouldHaveDetailTextSet() {
 342         String expectedStrength =
 343                 mContext.getResources().getStringArray(R.array.wifi_signal)[LEVEL];
 344
 345         mController.displayPreference(mockScreen);
 346
 347         verify(mockSignalStrengthPref).setDetailText(expectedStrength);
 348     }
 349
 350     @Test
 351     public void linkSpeedPref_shouldHaveDetailTextSet() {
 352         String expectedLinkSpeed = mContext.getString(R.string.link_speed, LINK_SPEED);
 353
 354         mController.displayPreference(mockScreen);
 355
 356         verify(mockLinkSpeedPref).setDetailText(expectedLinkSpeed);
 357     }
 358
 359     @Test
 360     public void linkSpeedPref_shouldNotShowIfNotSet() {
 361         when(mockWifiInfo.getLinkSpeed()).thenReturn(-1);
 362
 363         mController.displayPreference(mockScreen);
 364
 365         verify(mockLinkSpeedPref).setVisible(false);
 366     }
 367
 368     @Test
 369     public void macAddressPref_shouldHaveDetailTextSet() {
 370         mController.displayPreference(mockScreen);
 371
 372         verify(mockMacAddressPref).setDetailText(MAC_ADDRESS);
 373     }
 374
 375     @Test
 376     public void ipAddressPref_shouldHaveDetailTextSet() {
 377         mLinkProperties.addLinkAddress(Constants.IPV4_ADDR);
 378
 379         mController.displayPreference(mockScreen);
 380
 381         verify(mockIpAddressPref).setDetailText(Constants.IPV4_ADDR.getAddress().getHostAddress());
 382     }
 383
 384     @Test
 385     public void gatewayAndSubnet_shouldHaveDetailTextSet() {
 386         mLinkProperties.addLinkAddress(Constants.IPV4_ADDR);
 387         mLinkProperties.addRoute(Constants.IPV4_DEFAULT);
 388         mLinkProperties.addRoute(Constants.IPV4_SUBNET);
 389
 390         mController.displayPreference(mockScreen);
 391
 392         verify(mockSubnetPref).setDetailText("255.255.255.128");
 393         verify(mockGatewayPref).setDetailText("192.0.2.127");
 394     }
 395
 396     @Test
 397     public void dnsServersPref_shouldHaveDetailTextSet() throws UnknownHostException {
 398         mLinkProperties.addDnsServer(InetAddress.getByAddress(new byte[]{8,8,4,4}));
 399         mLinkProperties.addDnsServer(InetAddress.getByAddress(new byte[]{8,8,8,8}));
 400
 401         mController.displayPreference(mockScreen);
 402
 403         verify(mockDnsPref).setDetailText("8.8.4.4,8.8.8.8");
 404     }
 405
 406     @Test
 407     public void noCurrentNetwork_shouldFinishActivity() {
 408         // If WifiManager#getCurrentNetwork() returns null, then the network is neither connected
 409         // nor connecting and WifiStateMachine has not reached L2ConnectedState.
 410         when(mockWifiManager.getCurrentNetwork()).thenReturn(null);
 411
 412         mController.displayPreference(mockScreen);
 413
 414         verify(mockActivity).finish();
 415     }
 416
 417     @Test
 418     public void noLinkProperties_allIpDetailsHidden() {
 419         when(mockConnectivityManager.getLinkProperties(mockNetwork)).thenReturn(null);
 420         reset(mockIpv6Category, mockIpAddressPref, mockSubnetPref, mockGatewayPref,
 421                 mockDnsPref);
 422
 423         mController.displayPreference(mockScreen);
 424
 425         verify(mockIpv6Category).setVisible(false);
 426         verify(mockIpAddressPref).setVisible(false);
 427         verify(mockSubnetPref).setVisible(false);
 428         verify(mockGatewayPref).setVisible(false);
 429         verify(mockDnsPref).setVisible(false);
 430         verify(mockIpv6Category, never()).setVisible(true);
 431         verify(mockIpAddressPref, never()).setVisible(true);
 432         verify(mockSubnetPref, never()).setVisible(true);
 433         verify(mockGatewayPref, never()).setVisible(true);
 434         verify(mockDnsPref, never()).setVisible(true);
 435     }
 436
 437     // Convenience method to convert a LinkAddress to a string without a prefix length.
 438     private String asString(LinkAddress l) {
 439         return l.getAddress().getHostAddress();
 440     }
 441
 442     // Pretend that the NetworkCallback was triggered with a new copy of lp. We need to create a
 443     // new copy because the code only updates if !mLinkProperties.equals(lp).
 444     private void updateLinkProperties(LinkProperties lp) {
 445         mCallbackCaptor.getValue().onLinkPropertiesChanged(mockNetwork, new LinkProperties(lp));
 446     }
 447
 448     private void verifyDisplayedIpv6Addresses(InOrder inOrder, LinkAddress... addresses) {
 449         String text = Arrays.stream(addresses)
 450                 .map(address -> asString(address))
 451                 .collect(Collectors.joining("\n"));
 452         inOrder.verify(mockIpv6AddressesPref).setSummary(text);
 453     }
 454
 455     @Test
 456     public void onLinkPropertiesChanged_updatesFields() {
 457         mController.displayPreference(mockScreen);
 458         mController.onResume();
 459
 460         InOrder inOrder = inOrder(mockIpAddressPref, mockGatewayPref, mockSubnetPref,
 461                 mockDnsPref, mockIpv6Category, mockIpv6AddressesPref);
 462
 463         LinkProperties lp = new LinkProperties();
 464
 465         lp.addLinkAddress(Constants.IPV6_LINKLOCAL);
 466         updateLinkProperties(lp);
 467         verifyDisplayedIpv6Addresses(inOrder, Constants.IPV6_LINKLOCAL);
 468         inOrder.verify(mockIpv6Category).setVisible(true);
 469
 470         lp.addRoute(Constants.IPV4_DEFAULT);
 471         updateLinkProperties(lp);
 472         inOrder.verify(mockGatewayPref).setDetailText(Constants.IPV4_GATEWAY.getHostAddress());
 473         inOrder.verify(mockGatewayPref).setVisible(true);
 474
 475         lp.addLinkAddress(Constants.IPV4_ADDR);
 476         lp.addRoute(Constants.IPV4_SUBNET);
 477         updateLinkProperties(lp);
 478         inOrder.verify(mockIpAddressPref).setDetailText(asString(Constants.IPV4_ADDR));
 479         inOrder.verify(mockIpAddressPref).setVisible(true);
 480         inOrder.verify(mockSubnetPref).setDetailText("255.255.255.128");
 481         inOrder.verify(mockSubnetPref).setVisible(true);
 482
 483         lp.addLinkAddress(Constants.IPV6_GLOBAL1);
 484         lp.addLinkAddress(Constants.IPV6_GLOBAL2);
 485         updateLinkProperties(lp);
 486         verifyDisplayedIpv6Addresses(inOrder,
 487                 Constants.IPV6_LINKLOCAL,
 488                 Constants.IPV6_GLOBAL1,
 489                 Constants.IPV6_GLOBAL2);
 490
 491         lp.removeLinkAddress(Constants.IPV6_GLOBAL1);
 492         updateLinkProperties(lp);
 493         verifyDisplayedIpv6Addresses(inOrder,
 494                 Constants.IPV6_LINKLOCAL,
 495                 Constants.IPV6_GLOBAL2);
 496
 497         lp.addDnsServer(Constants.IPV6_DNS);
 498         updateLinkProperties(lp);
 499         inOrder.verify(mockDnsPref, never()).setVisible(true);
 500
 501         lp.addDnsServer(Constants.IPV4_DNS1);
 502         lp.addDnsServer(Constants.IPV4_DNS2);
 503         updateLinkProperties(lp);
 504         inOrder.verify(mockDnsPref).setDetailText(
 505                 Constants.IPV4_DNS1.getHostAddress() + "," +
 506                 Constants.IPV4_DNS2.getHostAddress());
 507         inOrder.verify(mockDnsPref).setVisible(true);
 508     }
 509
 510     @Test
 511     public void canForgetNetwork_noNetwork() {
 512         when(mockAccessPoint.getConfig()).thenReturn(null);
 513
 514         mController = newWifiDetailPreferenceController();
 515         mController.displayPreference(mockScreen);
 516
 517         verify(mockForgetButton).setVisibility(View.INVISIBLE);
 518     }
 519
 520     @Test
 521     public void canForgetNetwork_ephemeral() {
 522         when(mockWifiInfo.isEphemeral()).thenReturn(true);
 523         when(mockAccessPoint.getConfig()).thenReturn(null);
 524
 525         mController.displayPreference(mockScreen);
 526
 527         verify(mockForgetButton).setVisibility(View.VISIBLE);
 528     }
 529
 530     @Test
 531     public void canForgetNetwork_saved() {
 532         mController.displayPreference(mockScreen);
 533
 534         verify(mockForgetButton).setVisibility(View.VISIBLE);
 535     }
 536
 537     @Test
 538     public void forgetNetwork_ephemeral() {
 539         String ssid = "ssid";
 540         when(mockWifiInfo.isEphemeral()).thenReturn(true);
 541         when(mockWifiInfo.getSSID()).thenReturn(ssid);
 542
 543         mController.displayPreference(mockScreen);
 544         mForgetClickListener.getValue().onClick(null);
 545
 546         verify(mockWifiManager).disableEphemeralNetwork(ssid);
 547         verify(mockMetricsFeatureProvider)
 548                 .action(mockActivity, MetricsProto.MetricsEvent.ACTION_WIFI_FORGET);
 549     }
 550
 551     @Test
 552     public void forgetNetwork_saved() {
 553         mockWifiConfig.networkId = 5;
 554
 555         mController.displayPreference(mockScreen);
 556         mForgetClickListener.getValue().onClick(null);
 557
 558         verify(mockWifiManager).forget(mockWifiConfig.networkId, null);
 559         verify(mockMetricsFeatureProvider)
 560                 .action(mockActivity, MetricsProto.MetricsEvent.ACTION_WIFI_FORGET);
 561     }
 562
 563     @Test
 564     public void networkStateChangedIntent_shouldRefetchInfo() {
 565         mController.displayPreference(mockScreen);
 566         mController.onResume();
 567
 568         verify(mockConnectivityManager, times(1)).getNetworkInfo(any(Network.class));
 569         verify(mockWifiManager, times(1)).getConnectionInfo();
 570
 571         mContext.sendBroadcast(new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION));
 572
 573         verify(mockConnectivityManager, times(2)).getNetworkInfo(any(Network.class));
 574         verify(mockWifiManager, times(2)).getConnectionInfo();
 575     }
 576
 577     @Test
 578     public void rssiChangedIntent_shouldRefetchInfo() {
 579         mController.displayPreference(mockScreen);
 580         mController.onResume();
 581
 582         verify(mockConnectivityManager, times(1)).getNetworkInfo(any(Network.class));
 583         verify(mockWifiManager, times(1)).getConnectionInfo();
 584
 585         mContext.sendBroadcast(new Intent(WifiManager.RSSI_CHANGED_ACTION));
 586
 587         verify(mockConnectivityManager, times(2)).getNetworkInfo(any(Network.class));
 588         verify(mockWifiManager, times(2)).getConnectionInfo();
 589     }
 590
 591     @Test
 592     public void networkDisconnectdState_shouldFinishActivity() {
 593         mController.onResume();
 594
 595         when(mockConnectivityManager.getNetworkInfo(any(Network.class))).thenReturn(null);
 596         mContext.sendBroadcast(new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION));
 597
 598         verify(mockActivity).finish();
 599     }
 600
 601     @Test
 602     public void networkOnLost_shouldFinishActivity() {
 603         mController.displayPreference(mockScreen);
 604         mController.onResume();
 605
 606         mCallbackCaptor.getValue().onLost(mockNetwork);
 607
 608         verify(mockActivity).finish();
 609     }
 610
 611     @Test
 612     public void ipv6AddressPref_shouldHaveHostAddressTextSet() {
 613         mLinkProperties.addLinkAddress(Constants.IPV6_LINKLOCAL);
 614         mLinkProperties.addLinkAddress(Constants.IPV6_GLOBAL1);
 615         mLinkProperties.addLinkAddress(Constants.IPV6_GLOBAL2);
 616
 617         mController.displayPreference(mockScreen);
 618
 619         List <Preference> addrs = mIpv6AddressCaptor.getAllValues();
 620
 621         String expectedAddresses = String.join("\n",
 622                 asString(Constants.IPV6_LINKLOCAL),
 623                 asString(Constants.IPV6_GLOBAL1),
 624                 asString(Constants.IPV6_GLOBAL2));
 625
 626         verify(mockIpv6AddressesPref).setSummary(expectedAddresses);
 627     }
 628
 629     @Test
 630     public void ipv6AddressPref_shouldNotBeSelectable() {
 631         mLinkProperties.addLinkAddress(Constants.IPV6_GLOBAL2);
 632
 633         mController.displayPreference(mockScreen);
 634
 635         assertThat(mockIpv6AddressesPref.isSelectable()).isFalse();
 636     }
 637
 638     @Test
 639     public void captivePortal_shouldShowSignInButton() {
 640         InOrder inOrder = inOrder(mockSignInButton);
 641
 642         mController.displayPreference(mockScreen);
 643         mController.onResume();
 644
 645         inOrder.verify(mockSignInButton).setVisibility(View.INVISIBLE);
 646
 647         NetworkCapabilities nc = new NetworkCapabilities();
 648         nc.clearAll();
 649         nc.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
 650
 651         NetworkCallback callback = mCallbackCaptor.getValue();
 652         callback.onCapabilitiesChanged(mockNetwork, nc);
 653         inOrder.verify(mockSignInButton).setVisibility(View.INVISIBLE);
 654
 655         nc = new NetworkCapabilities(nc);
 656         nc.addCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL);
 657         callback.onCapabilitiesChanged(mockNetwork, nc);
 658         inOrder.verify(mockSignInButton).setVisibility(View.VISIBLE);
 659
 660         nc = new NetworkCapabilities(nc);
 661         nc.removeCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL);
 662         callback.onCapabilitiesChanged(mockNetwork, nc);
 663         inOrder.verify(mockSignInButton).setVisibility(View.INVISIBLE);
 664     }
 665
 666     @Test
 667     public void testSignInButton_shouldStartCaptivePortalApp() {
 668         mController.displayPreference(mockScreen);
 669
 670         ArgumentCaptor<OnClickListener> captor = ArgumentCaptor.forClass(OnClickListener.class);
 671         verify(mockSignInButton).setOnClickListener(captor.capture());
 672         captor.getValue().onClick(mockSignInButton);
 673         verify(mockConnectivityManagerWrapper).startCaptivePortalApp(mockNetwork);
 674     }
 675
 676     @Test
 677     public void signInButtonVisible_buttonPanelShouldBeVisible() {
 678         when(mockSignInButton.getVisibility()).thenReturn(View.VISIBLE);
 679         when(mockForgetButton.getVisibility()).thenReturn(View.INVISIBLE);
 680
 681         mController.displayPreference(mockScreen);
 682
 683         verify(mockButtonsPref).setVisible(true);
 684     }
 685
 686     @Test
 687     public void forgetButtonVisible_buttonPanelShouldBeVisible() {
 688         when(mockSignInButton.getVisibility()).thenReturn(View.INVISIBLE);
 689         when(mockForgetButton.getVisibility()).thenReturn(View.VISIBLE);
 690
 691         mController.displayPreference(mockScreen);
 692
 693         verify(mockButtonsPref).setVisible(true);
 694     }
 695
 696     @Test
 697     public void neitherButtonVisible_buttonPanelShouldBeInvisible() {
 698         when(mockSignInButton.getVisibility()).thenReturn(View.INVISIBLE);
 699         when(mockForgetButton.getVisibility()).thenReturn(View.INVISIBLE);
 700
 701         mController.displayPreference(mockScreen);
 702
 703         verify(mockButtonsPref).setVisible(false);
 704     }
 705 }