Merge "Move logic from SavedAccessPoint fragment to controller"

tests/robotests/src/com/android/settings/testutils/shadow/ShadowAccessPoint.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2018 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.testutils.shadow;
+
+import com.android.settingslib.wifi.AccessPoint;
+
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@Implements(AccessPoint.class)
+public class ShadowAccessPoint {
+
+    @Implementation
+    public String getSavedNetworkSummary() {
+        return "saved";
+    }
+}

tests/robotests/src/com/android/settings/testutils/shadow/ShadowWifiManager.java

@@ -20,13 +20,17 @@ import static org.robolectric.RuntimeEnvironment.application;
 
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
+import android.net.wifi.hotspot2.PasspointConfiguration;
 
 import org.robolectric.annotation.HiddenApi;
 import org.robolectric.annotation.Implementation;
 import org.robolectric.annotation.Implements;
 import org.robolectric.shadow.api.Shadow;
 
-@Implements(WifiManager.class)
+import java.util.Collections;
+import java.util.List;
+
+@Implements(value = WifiManager.class, inheritImplementationMethods = true)
 public class ShadowWifiManager extends org.robolectric.shadows.ShadowWifiManager {
 
     public WifiConfiguration savedWifiConfig;
@@ -43,6 +47,11 @@ public class ShadowWifiManager extends org.robolectric.shadows.ShadowWifiManager
         savedWifiConfig = config;
     }
 
+    @Implementation
+    public List<PasspointConfiguration> getPasspointConfigurations() {
+        return Collections.emptyList();
+    }
+
     public static ShadowWifiManager get() {
         return Shadow.extract(application.getSystemService(WifiManager.class));
     }

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

@@ -25,15 +25,7 @@ public class WifiDialogTest {
 
     private Context mContext = RuntimeEnvironment.application;
 
-    private WifiDialogListener mListener = new WifiDialogListener() {
-        @Override
-        public void onForget(WifiDialog dialog) {
-        }
-
-        @Override
-        public void onSubmit(WifiDialog dialog) {
-        }
-    };
+    private WifiDialogListener mListener = new WifiDialogListener() {};
 
     @Before
     public void setUp() {

tests/robotests/src/com/android/settings/wifi/savedaccesspoints/SavedAccessPointsPreferenceControllerTest.java

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2018 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.savedaccesspoints;
+
+import static com.android.settings.core.BasePreferenceController.AVAILABLE;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.net.wifi.WifiConfiguration;
+
+import androidx.preference.PreferenceCategory;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowAccessPoint;
+import com.android.settings.testutils.shadow.ShadowThreadUtils;
+import com.android.settings.testutils.shadow.ShadowWifiManager;
+import com.android.settingslib.wifi.AccessPointPreference;
+
+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.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = {ShadowThreadUtils.class, ShadowWifiManager.class})
+public class SavedAccessPointsPreferenceControllerTest {
+
+    @Mock
+    private PreferenceScreen mPreferenceScreen;
+    @Mock
+    private PreferenceCategory mPreferenceCategory;
+
+    private Context mContext;
+    private ShadowWifiManager mWifiManager;
+    private SavedAccessPointsPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+        mWifiManager = ShadowWifiManager.get();
+        mController = spy(new SavedAccessPointsPreferenceController(mContext, "test_key"));
+
+        when(mPreferenceScreen.findPreference(mController.getPreferenceKey()))
+                .thenReturn(mPreferenceCategory);
+        when(mPreferenceCategory.getContext()).thenReturn(mContext);
+    }
+
+    @Test
+    public void getAvailability_alwaysAvailable() {
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
+    }
+
+    @Test
+    public void onStart_shouldRefreshApList() {
+        doNothing().when(mController).refreshSavedAccessPoints();
+
+        mController.onStart();
+
+        verify(mController).refreshSavedAccessPoints();
+    }
+
+
+    @Test
+    public void postRefresh_shouldRefreshApList() {
+        doNothing().when(mController).refreshSavedAccessPoints();
+
+        mController.postRefreshSavedAccessPoints();
+
+        verify(mController).refreshSavedAccessPoints();
+    }
+
+    @Test
+    public void forget_onSuccess_shouldRefreshApList() {
+        doNothing().when(mController).refreshSavedAccessPoints();
+
+        mController.onSuccess();
+
+        verify(mController).refreshSavedAccessPoints();
+    }
+
+    @Test
+    public void forget_onFailure_shouldRefreshApList() {
+        doNothing().when(mController).refreshSavedAccessPoints();
+
+        mController.onFailure(0 /* reason */);
+
+        verify(mController).refreshSavedAccessPoints();
+    }
+
+    @Test
+    @Config(shadows = ShadowAccessPoint.class)
+    public void refreshSavedAccessPoints_shouldListAllAPs() {
+        final WifiConfiguration config = new WifiConfiguration();
+        config.SSID = "SSID";
+        config.BSSID = "BSSID";
+        config.networkId = 2;
+        mWifiManager.addNetwork(config);
+
+        final ArgumentCaptor<AccessPointPreference> captor =
+                ArgumentCaptor.forClass(AccessPointPreference.class);
+        mController.displayPreference(mPreferenceScreen);
+        mController.refreshSavedAccessPoints();
+
+        verify(mPreferenceCategory).addPreference(captor.capture());
+
+        final AccessPointPreference pref = captor.getValue();
+        assertThat(pref.getTitle()).isEqualTo(config.SSID);
+    }
+}

tests/robotests/src/com/android/settings/wifi/savedaccesspoints/SavedAccessPointsWifiSettingsTest.java

@@ -18,22 +18,20 @@ package com.android.settings.wifi.savedaccesspoints;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
-import android.net.wifi.WifiManager.ActionListener;
-import android.os.Handler;
 
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 import com.android.settings.wifi.WifiConfigController;
 import com.android.settings.wifi.WifiDialog;
+import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.wifi.AccessPoint;
 
 import org.junit.Before;
@@ -47,69 +45,53 @@ import org.robolectric.util.ReflectionHelpers;
 public class SavedAccessPointsWifiSettingsTest {
 
     @Mock
-    private WifiManager mockWifiManager;
+    private WifiManager mWifiManager;
     @Mock
-    private WifiDialog mockWifiDialog;
+    private WifiDialog mWifiDialog;
     @Mock
-    private WifiConfigController mockConfigController;
+    private WifiConfigController mConfigController;
     @Mock
-    private WifiConfiguration mockWifiConfiguration;
+    private WifiConfiguration mWifiConfiguration;
     @Mock
-    private AccessPoint mockAccessPoint;
+    private AccessPoint mAccessPoint;
     @Mock
-    private Handler mHandler;
+    private SavedAccessPointsPreferenceController mSavedApController;
 
-    private SavedAccessPointsWifiSettings mSettings;
+    private TestFragment mSettings;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mSettings = new SavedAccessPointsWifiSettings();
-        ReflectionHelpers.setField(mSettings, "mHandler", mHandler);
-        ReflectionHelpers.setField(mSettings, "mWifiManager", mockWifiManager);
+        mSettings = spy(new TestFragment());
 
-        when(mockWifiDialog.getController()).thenReturn(mockConfigController);
-        when(mockConfigController.getConfig()).thenReturn(mockWifiConfiguration);
+        doReturn(mSavedApController).when(mSettings)
+                .use(SavedAccessPointsPreferenceController.class);
+
+        ReflectionHelpers.setField(mSettings, "mWifiManager", mWifiManager);
+
+        when(mWifiDialog.getController()).thenReturn(mConfigController);
+        when(mConfigController.getConfig()).thenReturn(mWifiConfiguration);
     }
 
     @Test
-    public void onForget_isPasspointConfig_shouldSendMessageToHandler() {
-        final AccessPoint accessPoint = mock(AccessPoint.class);
-        when(accessPoint.isPasspointConfig()).thenReturn(true);
-        ReflectionHelpers.setField(mSettings, "mSelectedAccessPoint", accessPoint);
+    public void onForget_isPasspointConfig_shouldRefreshAPList() {
+        when(mAccessPoint.isPasspointConfig()).thenReturn(true);
+        ReflectionHelpers.setField(mSettings, "mSelectedAccessPoint", mAccessPoint);
 
         mSettings.onForget(null);
 
-        verify(mHandler).sendEmptyMessage(SavedAccessPointsWifiSettings.MSG_UPDATE_PREFERENCES);
-    }
-
-    @Test
-    public void onForget_onSuccess_shouldSendMessageToHandler() {
-        mSettings.mForgetListener.onSuccess();
-
-        verify(mHandler).sendEmptyMessage(SavedAccessPointsWifiSettings.MSG_UPDATE_PREFERENCES);
-    }
-
-    @Test
-    public void onForget_onFailure_shouldSendMessageToHandler() {
-        mSettings.mForgetListener.onFailure(0);
-
-        verify(mHandler).sendEmptyMessage(SavedAccessPointsWifiSettings.MSG_UPDATE_PREFERENCES);
-    }
-
-    @Test
-    public void onSubmit_shouldInvokeSaveApi() {
-        mSettings.onSubmit(mockWifiDialog);
-        verify(mockWifiManager).save(eq(mockWifiConfiguration), any(ActionListener.class));
+        verify(mSavedApController).postRefreshSavedAccessPoints();
     }
 
     @Test
     public void onForget_shouldInvokeForgetApi() {
-        ReflectionHelpers.setField(mSettings, "mSelectedAccessPoint", mockAccessPoint);
-        when(mockAccessPoint.getConfig()).thenReturn(mockWifiConfiguration);
-        mSettings.onForget(mockWifiDialog);
-        verify(mockWifiManager)
-                .forget(eq(mockWifiConfiguration.networkId), any(ActionListener.class));
+        ReflectionHelpers.setField(mSettings, "mSelectedAccessPoint", mAccessPoint);
+        when(mAccessPoint.getConfig()).thenReturn(mWifiConfiguration);
+
+        mSettings.onForget(mWifiDialog);
+
+        verify(mWifiManager)
+                .forget(mWifiConfiguration.networkId, mSavedApController);
     }
 
     @Test
@@ -118,4 +100,11 @@ public class SavedAccessPointsWifiSettingsTest {
         assertThat(mSettings.getPreferenceScreenResId())
                 .isEqualTo(R.xml.wifi_display_saved_access_points);
     }
+
+    public static class TestFragment extends SavedAccessPointsWifiSettings {
+
+        public <T extends AbstractPreferenceController> T use(Class<T> clazz) {
+            return super.use(clazz);
+        }
+    }
 }