PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "[Wi-Fi] Replace WifiTracker with WifiPickerTracker in WifiSettings"

Browse Source
This commit is contained in:
Arc Wang
2020-05-18 05:58:33 +00:00
committed by Android (Google) Code Review
parent ce91b77c75 41f23de712
commit 8c1c52f134
20 changed files with 737 additions and 3265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tests/robotests/src/com/android/settings/search/CustomSiteMapRegistryTest.java
View File

@@ -35,7 +35,7 @@ import com.android.settings.security.SecuritySettings;
import com.android.settings.security.screenlock.ScreenLockSettings;
import com.android.settings.system.SystemDashboardFragment;
import com.android.settings.wallpaper.WallpaperSuggestionActivity;
import com.android.settings.wifi.WifiSettings2;
import com.android.settings.wifi.WifiSettings;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -58,8 +58,8 @@ public class CustomSiteMapRegistryTest {
}
@Test
public void shouldContainWifiSettings2Pairs() {
assertThat(CustomSiteMapRegistry.CUSTOM_SITE_MAP.get(WifiSettings2.class.getName()))
public void shouldContainWifiSettingsPairs() {
assertThat(CustomSiteMapRegistry.CUSTOM_SITE_MAP.get(WifiSettings.class.getName()))
.isEqualTo(NetworkDashboardFragment.class.getName());
}

100
tests/robotests/src/com/android/settings/wifi/ConfigureAccessPointFragmentTest.java
View File

@@ -1,100 +0,0 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.wifi;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.app.settings.SettingsEnums;
import android.os.Bundle;
import com.android.settings.testutils.shadow.ShadowConnectivityManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.androidx.fragment.FragmentController;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = ShadowConnectivityManager.class)
public class ConfigureAccessPointFragmentTest {
private static final String KEY_SSID = "key_ssid";
private static final String KEY_SECURITY = "key_security";
private ConfigureAccessPointFragment mConfigureAccessPointFragment;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
Bundle bundle = new Bundle();
bundle.putString(KEY_SSID, "Test AP");
bundle.putInt(KEY_SECURITY, 1 /* WEP */);
mConfigureAccessPointFragment = spy(new ConfigureAccessPointFragment());
mConfigureAccessPointFragment.setArguments(bundle);
FragmentController.setupFragment(mConfigureAccessPointFragment);
}
@Test
public void getMetricsCategory_shouldReturnConfigureNetwork() {
assertThat(mConfigureAccessPointFragment.getMetricsCategory()).isEqualTo(
SettingsEnums.SETTINGS_WIFI_CONFIGURE_NETWORK);
}
@Test
public void getMode_shouldBeModeConnected() {
assertThat(mConfigureAccessPointFragment.getMode()).isEqualTo(
WifiConfigUiBase.MODE_CONNECT);
}
@Test
public void launchFragment_shouldShowSubmitButton() {
assertThat(mConfigureAccessPointFragment.getSubmitButton()).isNotNull();
}
@Test
public void launchFragment_shouldShowCancelButton() {
assertThat(mConfigureAccessPointFragment.getCancelButton()).isNotNull();
}
@Test
public void onClickSubmitButton_shouldHandleSubmitAction() {
mConfigureAccessPointFragment.getSubmitButton().performClick();
verify(mConfigureAccessPointFragment).handleSubmitAction();
}
@Test
public void dispatchSubmit_shouldHandleSubmitAction() {
mConfigureAccessPointFragment.dispatchSubmit();
verify(mConfigureAccessPointFragment).handleSubmitAction();
}
@Test
public void onClickCancelButton_shouldHandleCancelAction() {
mConfigureAccessPointFragment.getCancelButton().performClick();
verify(mConfigureAccessPointFragment).handleCancelAction();
}
}

94
tests/robotests/src/com/android/settings/wifi/ConnectedAccessPointPreferenceTest.java
View File

@@ -1,94 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.wifi;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.view.View;
import com.android.settings.R;
import com.android.settingslib.wifi.AccessPoint;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
@RunWith(RobolectricTestRunner.class)
public class ConnectedAccessPointPreferenceTest {
@Mock
private AccessPoint mAccessPoint;
@Mock
private View mView;
@Mock
private ConnectedAccessPointPreference.OnGearClickListener mOnGearClickListener;
private Context mContext;
private ConnectedAccessPointPreference mConnectedAccessPointPreference;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mConnectedAccessPointPreference = new ConnectedAccessPointPreference(mAccessPoint, mContext,
null, 0 /* iconResId */, false /* forSavedNetworks */, null /* fragment */);
mConnectedAccessPointPreference.setOnGearClickListener(mOnGearClickListener);
}
@Test
public void testOnClick_gearClicked_listenerInvoked() {
when(mView.getId()).thenReturn(R.id.settings_button);
mConnectedAccessPointPreference.onClick(mView);
verify(mOnGearClickListener).onGearClick(mConnectedAccessPointPreference);
}
@Test
public void testOnClick_gearNotClicked_listenerNotInvoked() {
mConnectedAccessPointPreference.onClick(mView);
verify(mOnGearClickListener, never()).onGearClick(mConnectedAccessPointPreference);
}
@Test
public void testCaptivePortalStatus_isCaptivePortal_dividerDrawn() {
mConnectedAccessPointPreference.setCaptivePortal(true);
assertThat(mConnectedAccessPointPreference.shouldShowDivider()).isTrue();
}
@Test
public void testCaptivePortalStatus_isNotCaptivePortal_dividerNotDrawn() {
mConnectedAccessPointPreference.setCaptivePortal(false);
assertThat(mConnectedAccessPointPreference.shouldShowDivider()).isFalse();
}
@Test
public void testWidgetLayoutPreference() {
assertThat(mConnectedAccessPointPreference.getWidgetLayoutResource())
.isEqualTo(R.layout.preference_widget_gear_optional_background);
}
}

367
tests/robotests/src/com/android/settings/wifi/WifiSettings2Test.java
View File

@@ -1,367 +0,0 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
*/
package com.android.settings.wifi;
import static com.android.settings.wifi.WifiConfigUiBase2.MODE_CONNECT;
import static com.android.settings.wifi.WifiConfigUiBase2.MODE_MODIFY;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
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.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.PowerManager;
import android.os.UserManager;
import android.provider.Settings;
import android.view.ContextMenu;
import android.view.View;
import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
import androidx.recyclerview.widget.RecyclerView;
import com.android.settings.R;
import com.android.settings.datausage.DataUsagePreference;
import com.android.settings.testutils.shadow.ShadowDataUsageUtils;
import com.android.settings.testutils.shadow.ShadowFragment;
import com.android.settingslib.wifi.LongPressWifiEntryPreference;
import com.android.wifitrackerlib.WifiEntry;
import com.android.wifitrackerlib.WifiPickerTracker;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowToast;
@RunWith(RobolectricTestRunner.class)
public class WifiSettings2Test {
private static final int NUM_NETWORKS = 4;
private static final String FAKE_URI_STRING = "fakeuri";
@Mock
private PowerManager mPowerManager;
@Mock
private WifiManager mWifiManager;
@Mock
private DataUsagePreference mDataUsagePreference;
private Context mContext;
private WifiSettings2 mWifiSettings2;
@Mock
private WifiPickerTracker mMockWifiPickerTracker;
@Mock
private PreferenceManager mPreferenceManager;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
mWifiSettings2 = spy(new WifiSettings2());
doReturn(mContext).when(mWifiSettings2).getContext();
doReturn(mPreferenceManager).when(mWifiSettings2).getPreferenceManager();
doReturn(mPowerManager).when(mContext).getSystemService(PowerManager.class);
doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class);
doReturn(mContext).when(mPreferenceManager).getContext();
mWifiSettings2.mAddWifiNetworkPreference = new AddWifiNetworkPreference(mContext);
mWifiSettings2.mSavedNetworksPreference = new Preference(mContext);
mWifiSettings2.mConfigureWifiSettingsPreference = new Preference(mContext);
mWifiSettings2.mWifiPickerTracker = mMockWifiPickerTracker;
mWifiSettings2.mWifiManager = mWifiManager;
}
@Test
public void addNetworkFragmentSendResult_onActivityResult_shouldHandleEvent() {
final WifiSettings2 wifiSettings2 = spy(new WifiSettings2());
final Intent intent = new Intent();
doNothing().when(wifiSettings2).handleAddNetworkRequest(anyInt(), any(Intent.class));
wifiSettings2.onActivityResult(WifiSettings2.ADD_NETWORK_REQUEST, Activity.RESULT_OK,
intent);
verify(wifiSettings2).handleAddNetworkRequest(anyInt(), any(Intent.class));
}
@Test
public void setAdditionalSettingsSummaries_hasSavedNetwork_preferenceVisible() {
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(NUM_NETWORKS);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(0 /* count */);
mWifiSettings2.setAdditionalSettingsSummaries();
assertThat(mWifiSettings2.mSavedNetworksPreference.isVisible()).isTrue();
assertThat(mWifiSettings2.mSavedNetworksPreference.getSummary()).isEqualTo(
mContext.getResources().getQuantityString(
R.plurals.wifi_saved_access_points_summary,
NUM_NETWORKS, NUM_NETWORKS));
}
@Test
public void setAdditionalSettingsSummaries_hasSavedPasspointNetwork_preferenceVisible() {
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(0 /* count */);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(NUM_NETWORKS);
mWifiSettings2.setAdditionalSettingsSummaries();
assertThat(mWifiSettings2.mSavedNetworksPreference.isVisible()).isTrue();
assertThat(mWifiSettings2.mSavedNetworksPreference.getSummary()).isEqualTo(
mContext.getResources().getQuantityString(
R.plurals.wifi_saved_passpoint_access_points_summary,
NUM_NETWORKS, NUM_NETWORKS));
}
@Test
public void setAdditionalSettingsSummaries_hasTwoKindsSavedNetwork_preferenceVisible() {
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(NUM_NETWORKS);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(NUM_NETWORKS);
mWifiSettings2.setAdditionalSettingsSummaries();
assertThat(mWifiSettings2.mSavedNetworksPreference.isVisible()).isTrue();
assertThat(mWifiSettings2.mSavedNetworksPreference.getSummary()).isEqualTo(
mContext.getResources().getQuantityString(
R.plurals.wifi_saved_all_access_points_summary,
NUM_NETWORKS*2, NUM_NETWORKS*2));
}
@Test
public void setAdditionalSettingsSummaries_noSavedNetwork_preferenceInvisible() {
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(0 /* count */);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(0 /* count */);
mWifiSettings2.setAdditionalSettingsSummaries();
assertThat(mWifiSettings2.mSavedNetworksPreference.isVisible()).isFalse();
}
@Test
public void setAdditionalSettingsSummaries_wifiWakeupEnabled_displayOn() {
final ContentResolver contentResolver = mContext.getContentResolver();
when(mWifiManager.isAutoWakeupEnabled()).thenReturn(true);
when(mWifiManager.isScanAlwaysAvailable()).thenReturn(true);
Settings.Global.putInt(contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0);
when(mPowerManager.isPowerSaveMode()).thenReturn(false);
mWifiSettings2.setAdditionalSettingsSummaries();
assertThat(mWifiSettings2.mConfigureWifiSettingsPreference.getSummary()).isEqualTo(
mContext.getString(R.string.wifi_configure_settings_preference_summary_wakeup_on));
}
@Test
public void setAdditionalSettingsSummaries_wifiWakeupDisabled_displayOff() {
final ContentResolver contentResolver = mContext.getContentResolver();
when(mWifiManager.isAutoWakeupEnabled()).thenReturn(false);
mWifiSettings2.setAdditionalSettingsSummaries();
assertThat(mWifiSettings2.mConfigureWifiSettingsPreference.getSummary()).isEqualTo(
mContext.getString(R.string.wifi_configure_settings_preference_summary_wakeup_off));
}
@Test
public void checkAddWifiNetworkPrefernce_preferenceVisible() {
assertThat(mWifiSettings2.mAddWifiNetworkPreference.isVisible()).isTrue();
assertThat(mWifiSettings2.mAddWifiNetworkPreference.getTitle()).isEqualTo(
mContext.getString(R.string.wifi_add_network));
}
private void setUpForOnCreate() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(mWifiSettings2.getActivity()).thenReturn(activity);
final Resources.Theme theme = mContext.getTheme();
when(activity.getTheme()).thenReturn(theme);
UserManager userManager = mock(UserManager.class);
when(activity.getSystemService(Context.USER_SERVICE))
.thenReturn(userManager);
when(mWifiSettings2.findPreference(WifiSettings2.PREF_KEY_DATA_USAGE))
.thenReturn(mDataUsagePreference);
}
@Test
@Config(shadows = {ShadowDataUsageUtils.class, ShadowFragment.class})
public void checkDataUsagePreference_perferenceInvisibleIfWifiNotSupported() {
setUpForOnCreate();
ShadowDataUsageUtils.IS_WIFI_SUPPORTED = false;
mWifiSettings2.onCreate(Bundle.EMPTY);
verify(mDataUsagePreference).setVisible(false);
}
@Test
@Config(shadows = {ShadowDataUsageUtils.class, ShadowFragment.class})
public void checkDataUsagePreference_perferenceVisibleIfWifiSupported() {
setUpForOnCreate();
ShadowDataUsageUtils.IS_WIFI_SUPPORTED = true;
mWifiSettings2.onCreate(Bundle.EMPTY);
verify(mDataUsagePreference).setVisible(true);
verify(mDataUsagePreference).setTemplate(any(), eq(0) /*subId*/, eq(null) /*service*/);
}
@Test
public void onCreateAdapter_hasStableIdsTrue() {
final PreferenceScreen preferenceScreen = mock(PreferenceScreen.class);
when(preferenceScreen.getContext()).thenReturn(mContext);
RecyclerView.Adapter adapter = mWifiSettings2.onCreateAdapter(preferenceScreen);
assertThat(adapter.hasStableIds()).isTrue();
}
@Test
public void onCreateContextMenu_shouldHaveForgetAndDisconnectMenuForConnectedWifiEntry() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(activity.getApplicationContext()).thenReturn(mContext);
when(mWifiSettings2.getActivity()).thenReturn(activity);
final WifiEntry wifiEntry = mock(WifiEntry.class);
when(wifiEntry.canDisconnect()).thenReturn(true);
when(wifiEntry.canForget()).thenReturn(true);
when(wifiEntry.isSaved()).thenReturn(true);
when(wifiEntry.getConnectedState()).thenReturn(WifiEntry.CONNECTED_STATE_CONNECTED);
final LongPressWifiEntryPreference connectedWifiEntryPreference =
mWifiSettings2.createLongPressWifiEntryPreference(wifiEntry);
final View view = mock(View.class);
when(view.getTag()).thenReturn(connectedWifiEntryPreference);
final ContextMenu menu = mock(ContextMenu.class);
mWifiSettings2.onCreateContextMenu(menu, view, null /* info */);
verify(menu).add(anyInt(), eq(WifiSettings2.MENU_ID_FORGET), anyInt(), anyInt());
verify(menu).add(anyInt(), eq(WifiSettings2.MENU_ID_DISCONNECT), anyInt(), anyInt());
}
@Test
public void onWifiEntriesChanged_shouldChangeNextButtonState() {
mWifiSettings2.onWifiEntriesChanged();
verify(mWifiSettings2).changeNextButtonState(anyBoolean());
}
@Test
public void openSubscriptionHelpPage_shouldCallStartActivityForResult() {
doReturn(new Intent()).when(mWifiSettings2).getHelpIntent(mContext, FAKE_URI_STRING);
doNothing().when(mWifiSettings2).startActivityForResult(any(Intent.class), anyInt());
final WifiEntry mockWifiEntry = mock(WifiEntry.class);
when(mockWifiEntry.getHelpUriString()).thenReturn(FAKE_URI_STRING);
mWifiSettings2.openSubscriptionHelpPage(mockWifiEntry);
verify(mWifiSettings2, times(1)).startActivityForResult(any(), anyInt());
}
@Test
public void onNumSavedNetworksChanged_isFinishing_ShouldNotCrash() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(activity.isFinishing()).thenReturn(true);
when(mWifiSettings2.getActivity()).thenReturn(activity);
when(mWifiSettings2.getContext()).thenReturn(null);
mWifiSettings2.onNumSavedNetworksChanged();
}
@Test
public void onNumSavedSubscriptionsChanged_isFinishing_ShouldNotCrash() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(activity.isFinishing()).thenReturn(true);
when(mWifiSettings2.getActivity()).thenReturn(activity);
when(mWifiSettings2.getContext()).thenReturn(null);
mWifiSettings2.onNumSavedSubscriptionsChanged();
}
@Test
public void onSubmit_modeModifyNoConfig_toastErrorMessage() {
WifiDialog2 dialog = createWifiDialog2(MODE_MODIFY, null /* config */);
mWifiSettings2.onSubmit(dialog);
assertThat(ShadowToast.getTextOfLatestToast()).isEqualTo(
mContext.getString(R.string.wifi_failed_save_message));
}
@Test
public void onSubmit_modeModifyHasConfig_saveWifiManager() {
final WifiConfiguration config = mock(WifiConfiguration.class);
WifiDialog2 dialog = createWifiDialog2(MODE_MODIFY, config);
mWifiSettings2.onSubmit(dialog);
verify(mWifiManager).save(eq(config), any());
}
@Test
public void onSubmit_modeConnectNoConfig_connectWifiEntry() {
WifiDialog2 dialog = createWifiDialog2(MODE_CONNECT, null /* config */);
final WifiEntry wifiEntry = dialog.getWifiEntry();
mWifiSettings2.onAttach(mContext);
mWifiSettings2.onSubmit(dialog);
verify(mWifiSettings2).connect(wifiEntry, false /* editIfNoConfig */,
false /* fullScreenEdit*/);
}
@Test
public void onSubmit_modeConnectHasConfig_connectWifiManager() {
final WifiConfiguration config = mock(WifiConfiguration.class);
WifiDialog2 dialog = createWifiDialog2(MODE_CONNECT, config);
mWifiSettings2.onSubmit(dialog);
verify(mWifiManager).connect(eq(config), any(WifiManager.ActionListener.class));
}
private WifiDialog2 createWifiDialog2(int mode, WifiConfiguration config) {
final WifiEntry wifiEntry = mock(WifiEntry.class);
when(wifiEntry.canConnect()).thenReturn(true);
final WifiConfigController2 controller = mock(WifiConfigController2.class);
when(controller.getConfig()).thenReturn(config);
final WifiDialog2 wifiDialog2 = spy(WifiDialog2.createModal(mContext, null /* listener */,
wifiEntry, mode));
when(wifiDialog2.getController()).thenReturn(controller);
return wifiDialog2;
}
}

326
tests/robotests/src/com/android/settings/wifi/WifiSettingsTest.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,17 +15,20 @@
*/
package com.android.settings.wifi;
import static android.net.wifi.WifiManager.WIFI_STATE_ENABLED;
import static com.android.settings.wifi.WifiConfigUiBase2.MODE_CONNECT;
import static com.android.settings.wifi.WifiConfigUiBase2.MODE_MODIFY;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -33,91 +36,58 @@ import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.wifi.EAPConstants;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.hotspot2.PasspointConfiguration;
import android.net.wifi.hotspot2.pps.Credential;
import android.net.wifi.hotspot2.pps.HomeSp;
import android.os.Bundle;
import android.os.PowerManager;
import android.os.UserManager;
import android.provider.Settings;
import android.util.FeatureFlagUtils;
import android.view.ContextMenu;
import android.view.View;
import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
import androidx.recyclerview.widget.RecyclerView;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import com.android.settings.datausage.DataUsagePreference;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.shadow.ShadowDataUsageUtils;
import com.android.settings.testutils.shadow.ShadowFragment;
import com.android.settings.widget.SwitchBar;
import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
import com.android.settingslib.wifi.AccessPoint;
import com.android.settingslib.wifi.WifiTracker;
import com.android.settingslib.wifi.WifiTrackerFactory;
import com.android.settingslib.wifi.LongPressWifiEntryPreference;
import com.android.wifitrackerlib.WifiEntry;
import com.android.wifitrackerlib.WifiPickerTracker;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.robolectric.shadows.ShadowToast;
@RunWith(RobolectricTestRunner.class)
public class WifiSettingsTest {
private static final int NUM_NETWORKS = 4;
private static final String FAKE_URI_STRING = "fakeuri";
@Mock
private WifiTracker mWifiTracker;
@Mock
private PowerManager mPowerManager;
@Mock
private DataUsagePreference mDataUsagePreference;
@Mock
private RecyclerView mRecyclerView;
@Mock
private RecyclerView.Adapter mRecyclerViewAdapter;
@Mock
private View mHeaderView;
@Mock
private WifiManager mWifiManager;
@Mock
private ConnectivityManager mConnectivityManager;
@Mock
private Intent mActivityIntent;
@Mock
private SwitchBar mSwitchBar;
@Mock
private WifiInfo mWifiInfo;
@Mock
private PackageManager mPackageManager;
private DataUsagePreference mDataUsagePreference;
private Context mContext;
private WifiSettings mWifiSettings;
private FakeFeatureFactory mFakeFeatureFactory;
private MetricsFeatureProvider mMetricsFeatureProvider;
@Mock
private WifiPickerTracker mMockWifiPickerTracker;
@Mock
private PreferenceManager mPreferenceManager;
@Before
public void setUp() {
@@ -126,75 +96,33 @@ public class WifiSettingsTest {
mWifiSettings = spy(new WifiSettings());
doReturn(mContext).when(mWifiSettings).getContext();
doReturn(mRecyclerViewAdapter).when(mRecyclerView).getAdapter();
doReturn(mRecyclerView).when(mWifiSettings).getListView();
doReturn(mPreferenceManager).when(mWifiSettings).getPreferenceManager();
doReturn(mPowerManager).when(mContext).getSystemService(PowerManager.class);
doReturn(mHeaderView).when(mWifiSettings).setPinnedHeaderView(anyInt());
doReturn(mWifiInfo).when(mWifiManager).getConnectionInfo();
doReturn(mWifiManager).when(mWifiTracker).getManager();
doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class);
doReturn(mContext).when(mPreferenceManager).getContext();
mWifiSettings.mAddWifiNetworkPreference = new AddWifiNetworkPreference(mContext);
mWifiSettings.mSavedNetworksPreference = new Preference(mContext);
mWifiSettings.mConfigureWifiSettingsPreference = new Preference(mContext);
mWifiSettings.mWifiTracker = mWifiTracker;
mWifiSettings.mWifiPickerTracker = mMockWifiPickerTracker;
mWifiSettings.mWifiManager = mWifiManager;
mWifiSettings.mConnectivityManager = mConnectivityManager;
mFakeFeatureFactory = FakeFeatureFactory.setupForTest();
mMetricsFeatureProvider = mFakeFeatureFactory.getMetricsFeatureProvider();
ReflectionHelpers.setField(mWifiSettings, "mMetricsFeatureProvider",
mMetricsFeatureProvider);
WifiTrackerFactory.setTestingWifiTracker(mWifiTracker);
}
@Test
public void addNetworkFragmentSendResult_onActivityResult_shouldHandleEvent() {
final WifiSettings wifiSettings = spy(new WifiSettings());
final WifiSettings WifiSettings = spy(new WifiSettings());
final Intent intent = new Intent();
doNothing().when(wifiSettings).handleAddNetworkRequest(anyInt(), any(Intent.class));
doNothing().when(WifiSettings).handleAddNetworkRequest(anyInt(), any(Intent.class));
wifiSettings.onActivityResult(WifiSettings.ADD_NETWORK_REQUEST, Activity.RESULT_OK, intent);
WifiSettings.onActivityResult(WifiSettings.ADD_NETWORK_REQUEST, Activity.RESULT_OK,
intent);
verify(wifiSettings).handleAddNetworkRequest(anyInt(), any(Intent.class));
}
private List<WifiConfiguration> createMockWifiConfigurations(int count) {
final List<WifiConfiguration> mockConfigs = new ArrayList<>();
for (int i = 0; i < count; i++) {
mockConfigs.add(new WifiConfiguration());
}
return mockConfigs;
}
private List<PasspointConfiguration> createMockPasspointConfigurations(int count) {
final List<PasspointConfiguration> mockConfigs = new ArrayList<>();
for (int i = 0; i < count; i++) {
final HomeSp sp = new HomeSp();
sp.setFqdn("fqdn");
final PasspointConfiguration config = new PasspointConfiguration();
config.setHomeSp(sp);
Credential.SimCredential simCredential = new Credential.SimCredential();
Credential credential = new Credential();
credential.setRealm("test.example.com");
simCredential.setImsi("12345*");
simCredential.setEapType(EAPConstants.EAP_SIM);
credential.setSimCredential(simCredential);
config.setCredential(credential);
mockConfigs.add(config);
}
return mockConfigs;
}
static NetworkCapabilities makeCaptivePortalNetworkCapabilities() {
final NetworkCapabilities capabilities = new NetworkCapabilities();
capabilities.clearAll();
capabilities.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
capabilities.addCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL);
return capabilities;
verify(WifiSettings).handleAddNetworkRequest(anyInt(), any(Intent.class));
}
@Test
public void setAdditionalSettingsSummaries_hasSavedNetwork_preferenceVisible() {
when(mWifiManager.getConfiguredNetworks())
.thenReturn(createMockWifiConfigurations(NUM_NETWORKS));
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(NUM_NETWORKS);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(0 /* count */);
mWifiSettings.setAdditionalSettingsSummaries();
@@ -207,8 +135,8 @@ public class WifiSettingsTest {
@Test
public void setAdditionalSettingsSummaries_hasSavedPasspointNetwork_preferenceVisible() {
when(mWifiManager.getPasspointConfigurations())
.thenReturn(createMockPasspointConfigurations(NUM_NETWORKS));
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(0 /* count */);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(NUM_NETWORKS);
mWifiSettings.setAdditionalSettingsSummaries();
@@ -221,10 +149,8 @@ public class WifiSettingsTest {
@Test
public void setAdditionalSettingsSummaries_hasTwoKindsSavedNetwork_preferenceVisible() {
when(mWifiManager.getConfiguredNetworks())
.thenReturn(createMockWifiConfigurations(NUM_NETWORKS));
when(mWifiManager.getPasspointConfigurations())
.thenReturn(createMockPasspointConfigurations(NUM_NETWORKS));
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(NUM_NETWORKS);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(NUM_NETWORKS);
mWifiSettings.setAdditionalSettingsSummaries();
@@ -237,8 +163,8 @@ public class WifiSettingsTest {
@Test
public void setAdditionalSettingsSummaries_noSavedNetwork_preferenceInvisible() {
when(mWifiManager.getConfiguredNetworks())
.thenReturn(createMockWifiConfigurations(0 /* count */));
when(mMockWifiPickerTracker.getNumSavedNetworks()).thenReturn(0 /* count */);
when(mMockWifiPickerTracker.getNumSavedSubscriptions()).thenReturn(0 /* count */);
mWifiSettings.setAdditionalSettingsSummaries();
@@ -278,29 +204,21 @@ public class WifiSettingsTest {
}
private void setUpForOnCreate() {
final SettingsActivity activity = mock(SettingsActivity.class);
when(activity.getSwitchBar()).thenReturn(mSwitchBar);
final FragmentActivity activity = mock(FragmentActivity.class);
when(mWifiSettings.getActivity()).thenReturn(activity);
final Resources.Theme theme = mContext.getTheme();
when(activity.getTheme()).thenReturn(theme);
when(activity.getIntent()).thenReturn(mActivityIntent);
UserManager userManager = mock(UserManager.class);
when(activity.getSystemService(Context.USER_SERVICE))
.thenReturn(userManager);
when(mWifiSettings.findPreference(WifiSettings.PREF_KEY_DATA_USAGE))
.thenReturn(mDataUsagePreference);
when(activity.getSystemService(Context.WIFI_SERVICE)).thenReturn(mWifiManager);
when(activity.getSystemService(ConnectivityManager.class)).thenReturn(mConnectivityManager);
when(activity.getPackageManager()).thenReturn(mPackageManager);
}
@Test
@Config(shadows = {ShadowDataUsageUtils.class, ShadowFragment.class})
public void checkDataUsagePreference_perferenceInvisibleIfWifiNotSupported() {
if (FeatureFlagUtils.isEnabled(mContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) {
return;
}
setUpForOnCreate();
ShadowDataUsageUtils.IS_WIFI_SUPPORTED = false;
@@ -312,10 +230,6 @@ public class WifiSettingsTest {
@Test
@Config(shadows = {ShadowDataUsageUtils.class, ShadowFragment.class})
public void checkDataUsagePreference_perferenceVisibleIfWifiSupported() {
if (FeatureFlagUtils.isEnabled(mContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) {
return;
}
setUpForOnCreate();
ShadowDataUsageUtils.IS_WIFI_SUPPORTED = true;
@@ -325,28 +239,6 @@ public class WifiSettingsTest {
verify(mDataUsagePreference).setTemplate(any(), eq(0) /*subId*/, eq(null) /*service*/);
}
@Test
public void onCreateContextMenu_shouldHaveForgetMenuForConnectedAccessPreference() {
final FragmentActivity mockActivity = mock(FragmentActivity.class);
when(mockActivity.getApplicationContext()).thenReturn(mContext);
when(mWifiSettings.getActivity()).thenReturn(mockActivity);
final AccessPoint accessPoint = mock(AccessPoint.class);
when(accessPoint.isConnectable()).thenReturn(false);
when(accessPoint.isSaved()).thenReturn(true);
when(accessPoint.isActive()).thenReturn(true);
final ConnectedAccessPointPreference connectedPreference =
mWifiSettings.createConnectedAccessPointPreference(accessPoint, mContext);
final View view = mock(View.class);
when(view.getTag()).thenReturn(connectedPreference);
final ContextMenu menu = mock(ContextMenu.class);
mWifiSettings.onCreateContextMenu(menu, view, null /* info */);
verify(menu).add(anyInt(), eq(WifiSettings.MENU_ID_FORGET), anyInt(), anyInt());
}
@Test
public void onCreateAdapter_hasStableIdsTrue() {
final PreferenceScreen preferenceScreen = mock(PreferenceScreen.class);
@@ -358,60 +250,118 @@ public class WifiSettingsTest {
}
@Test
@Config(shadows = {ShadowDataUsageUtils.class, ShadowFragment.class})
public void clickOnWifiNetworkWith_shouldStartCaptivePortalApp() {
if (FeatureFlagUtils.isEnabled(mContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) {
return;
}
public void onCreateContextMenu_shouldHaveForgetAndDisconnectMenuForConnectedWifiEntry() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(activity.getApplicationContext()).thenReturn(mContext);
when(mWifiSettings.getActivity()).thenReturn(activity);
when(mWifiManager.getConfiguredNetworks()).thenReturn(createMockWifiConfigurations(
NUM_NETWORKS));
when(mWifiTracker.isConnected()).thenReturn(true);
final WifiEntry wifiEntry = mock(WifiEntry.class);
when(wifiEntry.canDisconnect()).thenReturn(true);
when(wifiEntry.canForget()).thenReturn(true);
when(wifiEntry.isSaved()).thenReturn(true);
when(wifiEntry.getConnectedState()).thenReturn(WifiEntry.CONNECTED_STATE_CONNECTED);
final AccessPoint accessPointActive = mock(AccessPoint.class);
when(accessPointActive.isActive()).thenReturn(true);
when(accessPointActive.isSaved()).thenReturn(false);
when(accessPointActive.getConfig()).thenReturn(mock(WifiConfiguration.class));
final LongPressWifiEntryPreference connectedWifiEntryPreference =
mWifiSettings.createLongPressWifiEntryPreference(wifiEntry);
final View view = mock(View.class);
when(view.getTag()).thenReturn(connectedWifiEntryPreference);
final AccessPoint accessPointInactive = mock(AccessPoint.class);
when(accessPointInactive.isActive()).thenReturn(false);
when(accessPointInactive.isSaved()).thenReturn(false);
when(accessPointInactive.getConfig()).thenReturn(mock(WifiConfiguration.class));
final ContextMenu menu = mock(ContextMenu.class);
mWifiSettings.onCreateContextMenu(menu, view, null /* info */);
when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPointActive,
accessPointInactive));
when(mWifiManager.getWifiState()).thenReturn(WIFI_STATE_ENABLED);
when(mWifiManager.isWifiEnabled()).thenReturn(true);
verify(menu).add(anyInt(), eq(WifiSettings.MENU_ID_FORGET), anyInt(), anyInt());
verify(menu).add(anyInt(), eq(WifiSettings.MENU_ID_DISCONNECT), anyInt(), anyInt());
}
final Network network = mock(Network.class);
when(mWifiManager.getCurrentNetwork()).thenReturn(network);
@Test
public void onWifiEntriesChanged_shouldChangeNextButtonState() {
mWifiSettings.onWifiEntriesChanged();
// Simulate activity creation cycle
setUpForOnCreate();
ShadowDataUsageUtils.IS_WIFI_SUPPORTED = true;
mWifiSettings.onCreate(Bundle.EMPTY);
mWifiSettings.onActivityCreated(null);
mWifiSettings.onViewCreated(new View(mContext), new Bundle());
mWifiSettings.onStart();
verify(mWifiSettings).changeNextButtonState(anyBoolean());
}
// Click on open network
final Preference openWifiPref = new LongPressAccessPointPreference(accessPointInactive,
mContext, null,
false /* forSavedNetworks */, R.drawable.ic_wifi_signal_0,
null);
mWifiSettings.onPreferenceTreeClick(openWifiPref);
@Test
public void openSubscriptionHelpPage_shouldCallStartActivityForResult() {
doReturn(new Intent()).when(mWifiSettings).getHelpIntent(mContext, FAKE_URI_STRING);
doNothing().when(mWifiSettings).startActivityForResult(any(Intent.class), anyInt());
final WifiEntry mockWifiEntry = mock(WifiEntry.class);
when(mockWifiEntry.getHelpUriString()).thenReturn(FAKE_URI_STRING);
// Ensure connect() was called, and fake success.
ArgumentCaptor<WifiManager.ActionListener> wifiCallbackCaptor = ArgumentCaptor.forClass(
WifiManager.ActionListener.class);
verify(mWifiManager).connect(any(WifiConfiguration.class), wifiCallbackCaptor.capture());
wifiCallbackCaptor.getValue().onSuccess();
mWifiSettings.openSubscriptionHelpPage(mockWifiEntry);
// Simulate capability change
mWifiSettings.mCaptivePortalNetworkCallback.onCapabilitiesChanged(network,
makeCaptivePortalNetworkCapabilities());
verify(mWifiSettings, times(1)).startActivityForResult(any(), anyInt());
}
// Ensure CP was called
verify(mConnectivityManager).startCaptivePortalApp(eq(network));
@Test
public void onNumSavedNetworksChanged_isFinishing_ShouldNotCrash() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(activity.isFinishing()).thenReturn(true);
when(mWifiSettings.getActivity()).thenReturn(activity);
when(mWifiSettings.getContext()).thenReturn(null);
mWifiSettings.onNumSavedNetworksChanged();
}
@Test
public void onNumSavedSubscriptionsChanged_isFinishing_ShouldNotCrash() {
final FragmentActivity activity = mock(FragmentActivity.class);
when(activity.isFinishing()).thenReturn(true);
when(mWifiSettings.getActivity()).thenReturn(activity);
when(mWifiSettings.getContext()).thenReturn(null);
mWifiSettings.onNumSavedSubscriptionsChanged();
}
@Test
public void onSubmit_modeModifyNoConfig_toastErrorMessage() {
WifiDialog2 dialog = createWifiDialog2(MODE_MODIFY, null /* config */);
mWifiSettings.onSubmit(dialog);
assertThat(ShadowToast.getTextOfLatestToast()).isEqualTo(
mContext.getString(R.string.wifi_failed_save_message));
}
@Test
public void onSubmit_modeModifyHasConfig_saveWifiManager() {
final WifiConfiguration config = mock(WifiConfiguration.class);
WifiDialog2 dialog = createWifiDialog2(MODE_MODIFY, config);
mWifiSettings.onSubmit(dialog);
verify(mWifiManager).save(eq(config), any());
}
@Test
public void onSubmit_modeConnectNoConfig_connectWifiEntry() {
WifiDialog2 dialog = createWifiDialog2(MODE_CONNECT, null /* config */);
final WifiEntry wifiEntry = dialog.getWifiEntry();
mWifiSettings.onAttach(mContext);
mWifiSettings.onSubmit(dialog);
verify(mWifiSettings).connect(wifiEntry, false /* editIfNoConfig */,
false /* fullScreenEdit*/);
}
@Test
public void onSubmit_modeConnectHasConfig_connectWifiManager() {
final WifiConfiguration config = mock(WifiConfiguration.class);
WifiDialog2 dialog = createWifiDialog2(MODE_CONNECT, config);
mWifiSettings.onSubmit(dialog);
verify(mWifiManager).connect(eq(config), any(WifiManager.ActionListener.class));
}
private WifiDialog2 createWifiDialog2(int mode, WifiConfiguration config) {
final WifiEntry wifiEntry = mock(WifiEntry.class);
when(wifiEntry.canConnect()).thenReturn(true);
final WifiConfigController2 controller = mock(WifiConfigController2.class);
when(controller.getConfig()).thenReturn(config);
final WifiDialog2 wifiDialog2 = spy(WifiDialog2.createModal(mContext, null /* listener */,
wifiEntry, mode));
when(wifiDialog2.getController()).thenReturn(controller);
return wifiDialog2;
}
}