From 6620c84d8948c1fbb23ee309d1f39989e85ecac5 Mon Sep 17 00:00:00 2001 From: Jeremy Goldman Date: Wed, 9 Sep 2020 21:09:48 +0000 Subject: [PATCH] create junit MobileNetworkPreferenceControllerTest. 1. androidx lifecycle used rather than settingslib wrapper. This allows us to handle lifecycle events from junit tests as well. 2. Use Mocks or get/set functions rather than robolectric shadows. MobileNetworkPreferenceControllerTest Diff: https://diff.googleplex.com/#key=5P0b2G4iYmcz Test: atest -c MobileNetworkPreferenceControllerTest Change-Id: If49fe64e5db89a0cdcac7d26329b8c18626a00de --- .../MobileNetworkPreferenceController.java | 13 +- ...MobileNetworkPreferenceControllerTest.java | 193 ++++++++++++++++++ 2 files changed, 200 insertions(+), 6 deletions(-) create mode 100644 tests/unit/src/com/android/settings/network/MobileNetworkPreferenceControllerTest.java diff --git a/src/com/android/settings/network/MobileNetworkPreferenceController.java b/src/com/android/settings/network/MobileNetworkPreferenceController.java index 5612d2e824e..b968438df26 100644 --- a/src/com/android/settings/network/MobileNetworkPreferenceController.java +++ b/src/com/android/settings/network/MobileNetworkPreferenceController.java @@ -18,6 +18,8 @@ package com.android.settings.network; import static android.os.UserHandle.myUserId; import static android.os.UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS; +import static androidx.lifecycle.Lifecycle.Event; + import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; @@ -29,6 +31,8 @@ import android.telephony.ServiceState; import android.telephony.TelephonyManager; import androidx.annotation.VisibleForTesting; +import androidx.lifecycle.LifecycleObserver; +import androidx.lifecycle.OnLifecycleEvent; import androidx.preference.Preference; import androidx.preference.PreferenceScreen; @@ -39,12 +43,9 @@ import com.android.settingslib.RestrictedLockUtilsInternal; import com.android.settingslib.RestrictedPreference; import com.android.settingslib.Utils; import com.android.settingslib.core.AbstractPreferenceController; -import com.android.settingslib.core.lifecycle.LifecycleObserver; -import com.android.settingslib.core.lifecycle.events.OnStart; -import com.android.settingslib.core.lifecycle.events.OnStop; public class MobileNetworkPreferenceController extends AbstractPreferenceController - implements PreferenceControllerMixin, LifecycleObserver, OnStart, OnStop { + implements PreferenceControllerMixin, LifecycleObserver { @VisibleForTesting static final String KEY_MOBILE_NETWORK_SETTINGS = "mobile_network_settings"; @@ -96,7 +97,7 @@ public class MobileNetworkPreferenceController extends AbstractPreferenceControl return KEY_MOBILE_NETWORK_SETTINGS; } - @Override + @OnLifecycleEvent(Event.ON_START) public void onStart() { if (isAvailable()) { if (mPhoneStateListener == null) { @@ -115,7 +116,7 @@ public class MobileNetworkPreferenceController extends AbstractPreferenceControl } } - @Override + @OnLifecycleEvent(Event.ON_STOP) public void onStop() { if (mPhoneStateListener != null) { mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); diff --git a/tests/unit/src/com/android/settings/network/MobileNetworkPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/MobileNetworkPreferenceControllerTest.java new file mode 100644 index 00000000000..c540512c283 --- /dev/null +++ b/tests/unit/src/com/android/settings/network/MobileNetworkPreferenceControllerTest.java @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2020 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.network; + +import static androidx.lifecycle.Lifecycle.Event; + +import static com.google.common.truth.Truth.assertThat; + +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.content.Context; +import android.net.ConnectivityManager; +import android.os.Looper; +import android.os.UserManager; +import android.provider.Settings; +import android.provider.Settings.Global; +import android.telephony.PhoneStateListener; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.lifecycle.LifecycleOwner; +import androidx.lifecycle.LifecycleRegistry; +import androidx.preference.Preference; +import androidx.preference.PreferenceManager; +import androidx.preference.PreferenceScreen; +import androidx.test.annotation.UiThreadTest; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; +import com.android.settingslib.RestrictedPreference; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public class MobileNetworkPreferenceControllerTest { + private Context mContext; + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private SubscriptionManager mSubscriptionManager; + + @Mock + private UserManager mUserManager; + @Mock + private ConnectivityManager mConnectivityManager; + + private PreferenceManager mPreferenceManager; + private PreferenceScreen mScreen; + + @Mock + private LifecycleOwner mLifecycleOwner; + private LifecycleRegistry mLifecycleRegistry; + private MobileNetworkPreferenceController mController; + private Preference mPreference; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = spy(ApplicationProvider.getApplicationContext()); + when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); + when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); + when(mContext.getSystemService(UserManager.class)).thenReturn(mUserManager); + when(mContext.getSystemService(ConnectivityManager.class)).thenReturn(mConnectivityManager); + if (Looper.myLooper() == null) { + Looper.prepare(); + } + mPreferenceManager = new PreferenceManager(mContext); + mScreen = mPreferenceManager.createPreferenceScreen(mContext); + mPreference = new Preference(mContext); + mPreference.setKey(MobileNetworkPreferenceController.KEY_MOBILE_NETWORK_SETTINGS); + + mLifecycleRegistry = new LifecycleRegistry(mLifecycleOwner); + when(mLifecycleOwner.getLifecycle()).thenReturn(mLifecycleRegistry); + } + + @Test + public void secondaryUser_prefIsNotAvailable() { + when(mUserManager.isAdminUser()).thenReturn(false); + when(mConnectivityManager.isNetworkSupported(ConnectivityManager.TYPE_MOBILE)) + .thenReturn(true); + + mController = new MobileNetworkPreferenceController(mContext); + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void wifiOnly_prefIsNotAvailable() { + when(mUserManager.isAdminUser()).thenReturn(true); + when(mConnectivityManager.isNetworkSupported(ConnectivityManager.TYPE_MOBILE)) + .thenReturn(false); + + mController = new MobileNetworkPreferenceController(mContext); + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + @UiThreadTest + public void goThroughLifecycle_isAvailable_shouldListenToServiceChange() { + mController = spy(new MobileNetworkPreferenceController(mContext)); + mLifecycleRegistry.addObserver(mController); + doReturn(true).when(mController).isAvailable(); + + mLifecycleRegistry.handleLifecycleEvent(Event.ON_START); + verify(mController).onStart(); + verify(mTelephonyManager).listen(mController.mPhoneStateListener, + PhoneStateListener.LISTEN_SERVICE_STATE); + + mLifecycleRegistry.handleLifecycleEvent(Event.ON_STOP); + verify(mController).onStop(); + verify(mTelephonyManager).listen(mController.mPhoneStateListener, + PhoneStateListener.LISTEN_NONE); + } + + @Test + @UiThreadTest + public void serviceStateChange_shouldUpdatePrefSummary() { + final String testCarrierName = "test"; + + mController = spy(new MobileNetworkPreferenceController(mContext)); + mLifecycleRegistry.addObserver(mController); + doReturn(true).when(mController).isAvailable(); + + mScreen.addPreference(mPreference); + + // Display pref and go through lifecycle to set up listener. + mController.displayPreference(mScreen); + mLifecycleRegistry.handleLifecycleEvent(Event.ON_START); + verify(mController).onStart(); + verify(mTelephonyManager).listen(mController.mPhoneStateListener, + PhoneStateListener.LISTEN_SERVICE_STATE); + + doReturn(testCarrierName).when(mController).getSummary(); + + mController.mPhoneStateListener.onServiceStateChanged(null); + + // Carrier name should be set. + Assert.assertEquals(mPreference.getSummary(), testCarrierName); + } + + @Test + public void airplaneModeTurnedOn_shouldDisablePreference() { + Settings.Global.putInt(mContext.getContentResolver(), + Global.AIRPLANE_MODE_ON, 1); + mController = spy(new MobileNetworkPreferenceController(mContext)); + final RestrictedPreference mPreference = new RestrictedPreference(mContext); + mController.updateState(mPreference); + assertThat(mPreference.isEnabled()).isFalse(); + } + + @Test + public void airplaneModeTurnedOffAndNoUserRestriction_shouldEnablePreference() { + Settings.Global.putInt(mContext.getContentResolver(), + Global.AIRPLANE_MODE_ON, 0); + mController = spy(new MobileNetworkPreferenceController(mContext)); + final RestrictedPreference mPreference = new RestrictedPreference(mContext); + mPreference.setDisabledByAdmin(null); + mController.updateState(mPreference); + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void airplaneModeTurnedOffAndHasUserRestriction_shouldDisablePreference() { + Settings.Global.putInt(mContext.getContentResolver(), + Global.AIRPLANE_MODE_ON, 0); + mController = spy(new MobileNetworkPreferenceController(mContext)); + final RestrictedPreference mPreference = new RestrictedPreference(mContext); + mPreference.setDisabledByAdmin(EnforcedAdmin.MULTIPLE_ENFORCED_ADMIN); + mController.updateState(mPreference); + assertThat(mPreference.isEnabled()).isFalse(); + } +}