[Wi-Fi] Enhance WifiNoInternetDialogTest unit test cases

Add new unit test cases in WifiNoInternetDialogTest.java

The coverage rate of WifiNoInternetDialog will raise from 10% to 95%

Bug: 151696220
Test: make RunSettingsRoboTests ROBOTEST_FILTER=WifiNoInternetDialogTest
Change-Id: I8256c0adebee9a7f557b467a6ea11cad09e02b33

src/com/android/settings/wifi/WifiNoInternetDialog.java

@@ -38,11 +38,16 @@ import android.view.LayoutInflater;
 import android.view.View;
 import android.widget.CheckBox;
 
+import androidx.annotation.VisibleForTesting;
+
 import com.android.internal.app.AlertActivity;
 import com.android.internal.app.AlertController;
 import com.android.settings.R;
 
-public final class WifiNoInternetDialog extends AlertActivity implements
+/**
+ * To display a dialog that asks the user whether to connect to a network that is not validated.
+ */
+public class WifiNoInternetDialog extends AlertActivity implements
         DialogInterface.OnClickListener {
     private static final String TAG = "WifiNoInternetDialog";
 
@@ -50,7 +55,7 @@ public final class WifiNoInternetDialog extends AlertActivity implements
     private Network mNetwork;
     private String mNetworkName;
     private ConnectivityManager.NetworkCallback mNetworkCallback;
-    private CheckBox mAlwaysAllow;
+    @VisibleForTesting CheckBox mAlwaysAllow;
     private String mAction;
     private boolean mButtonClicked;
 

tests/robotests/src/com/android/settings/wifi/WifiNoInternetDialogTest.java

@@ -16,16 +16,234 @@
 
 package com.android.settings.wifi;
 
+import static android.net.ConnectivityManager.ACTION_PROMPT_LOST_VALIDATION;
+import static android.net.ConnectivityManager.ACTION_PROMPT_PARTIAL_CONNECTIVITY;
+import static android.net.ConnectivityManager.ACTION_PROMPT_UNVALIDATED;
+import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.net.NetworkRequest;
+import android.net.Uri;
+import android.os.Bundle;
+
+import com.android.settings.R;
+
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 import org.robolectric.Robolectric;
 import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
 
 @RunWith(RobolectricTestRunner.class)
 public class WifiNoInternetDialogTest {
+
+    private static final String FAKE_NETWORK_ID = "13";
+    private static final String FAKE_URL = "netId:13";
+    private static final String WRONG_URL = "netId:";
+    private static final String FAKE_SSID = "fake_ssid";
+
+    @Captor
+    private ArgumentCaptor<ConnectivityManager.NetworkCallback> mCallbackCaptor;
+
+    @Mock
+    private ConnectivityManager mConnectivityManager;
+
+    @Mock
+    private NetworkInfo mNetworkInfo;
+
+    @Mock
+    private NetworkCapabilities mNetworkCapabilities;
+
+    private WifiNoInternetDialog mActivity;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
     @Test
     public void launchActivity_noIntentAction_shouldNotFatalException() {
         WifiNoInternetDialog wifiNoInternetDialog =
                 Robolectric.setupActivity(WifiNoInternetDialog.class);
     }
-}
+
+    @Test
+    public void setupPromptUnvalidated_shouldShowNoInternetAccessRemember() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, FAKE_URL);
+        setupNetworkComponents();
+
+        mActivity.onCreate(new Bundle());
+
+        assertThat(mActivity.mAlwaysAllow.getText()).isEqualTo(
+                mActivity.getString(R.string.no_internet_access_remember));
+    }
+
+    @Test
+    public void setupPromptPartialConnectivity_shouldShowNoInternetAccessRemember() {
+        setupActivityWithAction(ACTION_PROMPT_PARTIAL_CONNECTIVITY, FAKE_URL);
+        setupNetworkComponents();
+
+        mActivity.onCreate(new Bundle());
+
+        assertThat(mActivity.mAlwaysAllow.getText()).isEqualTo(
+                mActivity.getString(R.string.no_internet_access_remember));
+    }
+
+    @Test
+    public void setupPromptLostValidationAction_shouldShowLostInternetAccessPersist() {
+        setupActivityWithAction(ACTION_PROMPT_LOST_VALIDATION, FAKE_URL);
+        setupNetworkComponents();
+
+        mActivity.onCreate(new Bundle());
+
+        assertThat(mActivity.mAlwaysAllow.getText()).isEqualTo(
+                mActivity.getString(R.string.lost_internet_access_persist));
+    }
+
+    @Test
+    public void clickPositiveButton_whenPromptUnvalidated_shouldCallSetAcceptUnvalidated() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, FAKE_URL);
+        setupNetworkComponents();
+        mActivity.onCreate(new Bundle());
+
+        mActivity.onClick(null, DialogInterface.BUTTON_POSITIVE);
+
+        verify(mConnectivityManager).setAcceptUnvalidated(any(Network.class), eq(true), eq(false));
+    }
+
+    @Test
+    public void positiveButton_withPartialConnectivity_shouldCallSetAcceptPartialConnectivity() {
+        setupActivityWithAction(ACTION_PROMPT_PARTIAL_CONNECTIVITY, FAKE_URL);
+        setupNetworkComponents();
+        mActivity.onCreate(new Bundle());
+
+        mActivity.onClick(null, DialogInterface.BUTTON_POSITIVE);
+
+        verify(mConnectivityManager).setAcceptPartialConnectivity(any(Network.class), eq(true),
+                eq(false));
+    }
+
+    @Test
+    public void positiveButton_withLostValidation_shouldCallSetAvoidUnvalidated() {
+        setupActivityWithAction(ACTION_PROMPT_LOST_VALIDATION, FAKE_URL);
+        setupNetworkComponents();
+        mActivity.onCreate(new Bundle());
+
+        mActivity.onClick(null, DialogInterface.BUTTON_POSITIVE);
+
+        verify(mConnectivityManager).setAvoidUnvalidated(any(Network.class));
+    }
+
+    @Test
+    public void destroyWithNoClick_inPartialConnectivity_shouldCallSetAcceptPartialConnectivity() {
+        setupActivityWithAction(ACTION_PROMPT_PARTIAL_CONNECTIVITY, FAKE_URL);
+        setupNetworkComponents();
+        when(mActivity.isFinishing()).thenReturn(true);
+        mActivity.onCreate(new Bundle());
+
+        mActivity.onDestroy();
+
+        verify(mConnectivityManager).setAcceptPartialConnectivity(any(Network.class), eq(false),
+                eq(false));
+    }
+
+    @Test
+    public void destroyWithNoClick_whenUnvalidated_shouldCallSetAcceptUnvalidated() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, FAKE_URL);
+        setupNetworkComponents();
+        when(mActivity.isFinishing()).thenReturn(true);
+        mActivity.onCreate(new Bundle());
+
+        mActivity.onDestroy();
+
+        verify(mConnectivityManager).setAcceptUnvalidated(any(Network.class), eq(false), eq(false));
+    }
+
+    @Test
+    public void networkCallbackOnLost_shouldFinish() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, FAKE_URL);
+        setupNetworkComponents();
+        mActivity.onCreate(new Bundle());
+        verify(mConnectivityManager, times(1)).registerNetworkCallback(
+                any(NetworkRequest.class), mCallbackCaptor.capture());
+
+        mCallbackCaptor.getValue().onLost(new Network(Integer.parseInt(FAKE_NETWORK_ID)));
+
+        verify(mActivity).finish();
+    }
+
+    @Test
+    public void networkCallbackOnCapabilitiesChanged_shouldFinish() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, FAKE_URL);
+        setupNetworkComponents();
+        when(mNetworkCapabilities.hasCapability(NET_CAPABILITY_VALIDATED)).thenReturn(true);
+        mActivity.onCreate(new Bundle());
+        verify(mConnectivityManager, times(1)).registerNetworkCallback(
+                any(NetworkRequest.class), mCallbackCaptor.capture());
+
+        mCallbackCaptor.getValue().onCapabilitiesChanged(
+                new Network(Integer.parseInt(FAKE_NETWORK_ID)), mNetworkCapabilities);
+
+        verify(mActivity).finish();
+    }
+
+    @Test
+    public void networkNotConnectedOrConnecting_shouldFinish() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, FAKE_URL);
+        setupNetworkComponents();
+        when(mNetworkInfo.isConnectedOrConnecting()).thenReturn(false);
+
+        mActivity.onCreate(new Bundle());
+
+        verify(mActivity).finish();
+    }
+
+    @Test
+    public void withWrongUrl_shouldFinish() {
+        setupActivityWithAction(ACTION_PROMPT_UNVALIDATED, WRONG_URL);
+        setupNetworkComponents();
+
+        mActivity.onCreate(new Bundle());
+
+        verify(mActivity).finish();
+    }
+
+    private void setupNetworkComponents() {
+        when(mActivity.getSystemService(Context.CONNECTIVITY_SERVICE))
+                .thenReturn(mConnectivityManager);
+        when(mNetworkInfo.isConnectedOrConnecting()).thenReturn(true);
+        when(mNetworkCapabilities.getSsid()).thenReturn(FAKE_SSID);
+        when(mConnectivityManager.getNetworkInfo(any()))
+                .thenReturn(mNetworkInfo);
+        when(mConnectivityManager.getNetworkCapabilities(any()))
+                .thenReturn(mNetworkCapabilities);
+    }
+
+    private void setupActivityWithAction(String action, String url) {
+        final Intent intent = new Intent(action).setClassName(
+                RuntimeEnvironment.application.getPackageName(),
+                WifiNoInternetDialog.class.getName());
+        intent.setData(Uri.parse(url));
+        mActivity = spy(Robolectric.buildActivity(WifiNoInternetDialog.class, intent).get());
+    }
+}