From dcef423720eeda987811ccaf65a8de0f4c72e64c Mon Sep 17 00:00:00 2001 From: Bonian Chen Date: Sun, 19 Apr 2020 17:54:33 +0800 Subject: [PATCH] [Settings] Refactor test case DataUsageSummaryPreferenceControllerTest Refactor test case of DataUsageSummaryPreferenceControllerTest Bug: 141833767 Test: make RunSettingsRoboTests -j ROBOTEST_FILTER=DataUsageSummaryPreferenceControllerTest Change-Id: Ieb551a32d87c53cbd0765e19e710f1f0469da9d5 --- .../DataUsageSummaryPreferenceController.java | 87 ++++----- ...aUsageSummaryPreferenceControllerTest.java | 181 ++++++++++-------- 2 files changed, 142 insertions(+), 126 deletions(-) diff --git a/src/com/android/settings/datausage/DataUsageSummaryPreferenceController.java b/src/com/android/settings/datausage/DataUsageSummaryPreferenceController.java index bfe78e5de07..42c2b736839 100644 --- a/src/com/android/settings/datausage/DataUsageSummaryPreferenceController.java +++ b/src/com/android/settings/datausage/DataUsageSummaryPreferenceController.java @@ -68,13 +68,12 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll private final EntityHeaderController mEntityHeaderController; private final Lifecycle mLifecycle; private final PreferenceFragmentCompat mFragment; - protected final DataUsageController mDataUsageController; - protected final DataUsageInfoController mDataInfoController; - private final NetworkTemplate mDefaultTemplate; - protected final NetworkPolicyEditor mPolicyEditor; - private final int mDataUsageTemplate; - private final boolean mHasMobileData; - private final SubscriptionManager mSubscriptionManager; + protected DataUsageController mDataUsageController; + protected DataUsageInfoController mDataInfoController; + private NetworkTemplate mDefaultTemplate; + protected NetworkPolicyEditor mPolicyEditor; + private int mDataUsageTemplate; + private boolean mHasMobileData; /** Name of the carrier, or null if not available */ private CharSequence mCarrierName; @@ -112,29 +111,31 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll fragment, null); mLifecycle = lifecycle; mFragment = fragment; + init(subscriptionId); + } + + protected void init(int subscriptionId) { mSubscriptionId = subscriptionId; - mDefaultTemplate = DataUsageUtils.getDefaultTemplate(activity, mSubscriptionId); - NetworkPolicyManager policyManager = activity.getSystemService(NetworkPolicyManager.class); + mDefaultTemplate = DataUsageUtils.getDefaultTemplate(mContext, mSubscriptionId); + final NetworkPolicyManager policyManager = + mContext.getSystemService(NetworkPolicyManager.class); mPolicyEditor = new NetworkPolicyEditor(policyManager); mHasMobileData = SubscriptionManager.isValidSubscriptionId(mSubscriptionId) - && DataUsageUtils.hasMobileData(activity); + && DataUsageUtils.hasMobileData(mContext); - mDataUsageController = new DataUsageController(activity); + mDataUsageController = new DataUsageController(mContext); mDataUsageController.setSubscriptionId(mSubscriptionId); mDataInfoController = new DataUsageInfoController(); if (mHasMobileData) { mDataUsageTemplate = R.string.cell_data_template; - } else if (DataUsageUtils.hasWifiRadio(activity)) { + } else if (DataUsageUtils.hasWifiRadio(mContext)) { mDataUsageTemplate = R.string.wifi_data_template; } else { mDataUsageTemplate = R.string.ethernet_data_template; } - - mSubscriptionManager = (SubscriptionManager) - mContext.getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE); } @VisibleForTesting @@ -144,8 +145,6 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll NetworkTemplate defaultTemplate, NetworkPolicyEditor policyEditor, int dataUsageTemplate, - boolean hasMobileData, - SubscriptionManager subscriptionManager, Activity activity, Lifecycle lifecycle, EntityHeaderController entityHeaderController, @@ -157,8 +156,7 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll mDefaultTemplate = defaultTemplate; mPolicyEditor = policyEditor; mDataUsageTemplate = dataUsageTemplate; - mHasMobileData = hasMobileData; - mSubscriptionManager = subscriptionManager; + mHasMobileData = true; mActivity = activity; mLifecycle = lifecycle; mEntityHeaderController = entityHeaderController; @@ -174,24 +172,25 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll } @VisibleForTesting - void setPlanValues(int dataPlanCount, long dataPlanSize, long dataPlanUse) { - mDataplanCount = dataPlanCount; - mDataplanSize = dataPlanSize; - mDataBarSize = dataPlanSize; - mDataplanUse = dataPlanUse; + List getSubscriptionPlans(int subscriptionId) { + return ProxySubscriptionManager.getInstance(mContext).get() + .getSubscriptionPlans(subscriptionId); } @VisibleForTesting - void setCarrierValues(String carrierName, long snapshotTime, long cycleEnd, Intent intent) { - mCarrierName = carrierName; - mSnapshotTime = snapshotTime; - mCycleEnd = cycleEnd; - mManageSubscriptionIntent = intent; + SubscriptionInfo getSubscriptionInfo(int subscriptionId) { + return ProxySubscriptionManager.getInstance(mContext) + .getAccessibleSubscriptionInfo(subscriptionId); + } + + @VisibleForTesting + boolean hasSim() { + return DataUsageUtils.hasSim(mContext); } @Override public int getAvailabilityStatus() { - return DataUsageUtils.hasSim(mActivity) + return hasSim() || DataUsageUtils.hasWifiRadio(mContext) ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; } @@ -200,7 +199,8 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll DataUsageSummaryPreference summaryPreference = (DataUsageSummaryPreference) preference; final DataUsageController.DataUsageInfo info; - if (DataUsageUtils.hasSim(mActivity)) { + final SubscriptionInfo subInfo = getSubscriptionInfo(mSubscriptionId); + if (hasSim()) { info = mDataUsageController.getDataUsageInfo(mDefaultTemplate); mDataInfoController.updateDataLimit(info, mPolicyEditor.getPolicy(mDefaultTemplate)); summaryPreference.setWifiMode(/* isWifiMode */ false, @@ -223,9 +223,7 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll return; } - if (mSubscriptionManager != null) { - refreshDataplanInfo(info); - } + refreshDataplanInfo(info, subInfo); if (info.warningLevel > 0 && info.limitLevel > 0) { summaryPreference.setLimitInfo(TextUtils.expandTemplate( @@ -260,7 +258,8 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll // TODO(b/70950124) add test for this method once the robolectric shadow run script is // completed (b/3526807) - private void refreshDataplanInfo(DataUsageController.DataUsageInfo info) { + private void refreshDataplanInfo(DataUsageController.DataUsageInfo info, + SubscriptionInfo subInfo) { // reset data before overwriting mCarrierName = null; mDataplanCount = 0; @@ -271,16 +270,10 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll mCycleEnd = info.cycleEnd; mSnapshotTime = -1L; - final ProxySubscriptionManager proxySubsciptionMgr = - ProxySubscriptionManager.getInstance(mContext); - final SubscriptionInfo subInfo = proxySubsciptionMgr - .getAccessibleSubscriptionInfo(mSubscriptionId); if (subInfo != null && mHasMobileData) { mCarrierName = subInfo.getCarrierName(); - List plans = mSubscriptionManager.getSubscriptionPlans( - mSubscriptionId); - final SubscriptionPlan primaryPlan = getPrimaryPlan(mSubscriptionManager, - mSubscriptionId); + final List plans = getSubscriptionPlans(mSubscriptionId); + final SubscriptionPlan primaryPlan = getPrimaryPlan(plans); if (primaryPlan != null) { mDataplanCount = plans.size(); @@ -313,7 +306,8 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll * {@code null} if no carrier app is defined, or if the defined * carrier app provides no management activity. */ - private Intent createManageSubscriptionIntent(int subId) { + @VisibleForTesting + Intent createManageSubscriptionIntent(int subId) { final INetworkPolicyManager iNetPolicyManager = INetworkPolicyManager.Stub.asInterface( ServiceManager.getService(Context.NETWORK_POLICY_SERVICE)); String owner = ""; @@ -327,7 +321,7 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll return null; } - final List plans = mSubscriptionManager.getSubscriptionPlans(subId); + final List plans = getSubscriptionPlans(subId); if (plans.isEmpty()) { return null; } @@ -344,8 +338,7 @@ public class DataUsageSummaryPreferenceController extends BasePreferenceControll return intent; } - public static SubscriptionPlan getPrimaryPlan(SubscriptionManager subManager, int primaryId) { - List plans = subManager.getSubscriptionPlans(primaryId); + private static SubscriptionPlan getPrimaryPlan(List plans) { if (CollectionUtils.isEmpty(plans)) { return null; } diff --git a/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryPreferenceControllerTest.java index eab3dde65f9..d6f3e947d87 100644 --- a/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryPreferenceControllerTest.java @@ -34,8 +34,11 @@ import android.content.Context; import android.content.Intent; import android.net.ConnectivityManager; import android.net.NetworkTemplate; +import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; +import android.telephony.SubscriptionPlan; import android.telephony.TelephonyManager; +import android.util.RecurrenceRule; import androidx.fragment.app.FragmentActivity; import androidx.preference.PreferenceFragmentCompat; @@ -63,6 +66,10 @@ import org.robolectric.RobolectricTestRunner; import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; import java.util.concurrent.TimeUnit; @RunWith(RobolectricTestRunner.class) @@ -86,7 +93,9 @@ public class DataUsageSummaryPreferenceControllerTest { @Mock private NetworkTemplate mNetworkTemplate; @Mock - private SubscriptionManager mSubscriptionManager; + private SubscriptionInfo mSubscriptionInfo; + @Mock + private SubscriptionPlan mSubscriptionPlan; @Mock private Lifecycle mLifecycle; @Mock(answer = Answers.RETURNS_DEEP_STUBS) @@ -105,6 +114,7 @@ public class DataUsageSummaryPreferenceControllerTest { private Context mContext; private DataUsageSummaryPreferenceController mController; private int mDefaultSubscriptionId; + private List mSubscriptionPlans; @Before public void setUp() { @@ -112,30 +122,45 @@ public class DataUsageSummaryPreferenceControllerTest { mContext = spy(RuntimeEnvironment.application); doReturn("%1$s %2%s").when(mContext) - .getString(com.android.internal.R.string.fileSizeSuffix); + .getString(com.android.internal.R.string.fileSizeSuffix); + + mDefaultSubscriptionId = 1234; + mSubscriptionPlans = new ArrayList(); mFactory = FakeFeatureFactory.setupForTest(); when(mFactory.metricsFeatureProvider.getMetricsCategory(any(Object.class))) .thenReturn(MetricsProto.MetricsEvent.SETTINGS_APP_NOTIF_CATEGORY); ShadowEntityHeaderController.setUseMock(mHeaderController); - mDataInfoController = new DataUsageInfoController(); + + mDataInfoController = spy(new DataUsageInfoController()); + doReturn(-1L).when(mDataInfoController).getSummaryLimit(any()); mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get()); - when(mActivity.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); + doReturn(mTelephonyManager).when(mActivity).getSystemService(TelephonyManager.class); + doReturn(mTelephonyManager).when(mTelephonyManager) + .createForSubscriptionId(mDefaultSubscriptionId); when(mActivity.getSystemService(Context.CONNECTIVITY_SERVICE)) .thenReturn(mConnectivityManager); - when(mTelephonyManager.getSimState()).thenReturn(TelephonyManager.SIM_STATE_READY); + doReturn(TelephonyManager.SIM_STATE_READY).when(mTelephonyManager).getSimState(); when(mConnectivityManager.isNetworkSupported(TYPE_WIFI)).thenReturn(false); - mDefaultSubscriptionId = 1234; - mController = new DataUsageSummaryPreferenceController( + + mController = spy(new DataUsageSummaryPreferenceController( mDataUsageController, mDataInfoController, mNetworkTemplate, mPolicyEditor, R.string.cell_data_template, - true, - null, - mActivity, null, null, null, mDefaultSubscriptionId); + mActivity, null, null, null, mDefaultSubscriptionId)); + doReturn(null).when(mController).getSubscriptionInfo( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + doReturn(null).when(mController).getSubscriptionPlans( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + + doReturn(CARRIER_NAME).when(mSubscriptionInfo).getCarrierName(); + doReturn(mSubscriptionInfo).when(mController).getSubscriptionInfo(mDefaultSubscriptionId); + doReturn(mSubscriptionPlans).when(mController).getSubscriptionPlans(mDefaultSubscriptionId); + + doReturn(true).when(mController).hasSim(); } @After @@ -150,9 +175,10 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(1 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); + createTestDataPlan(info.cycleStart, info.cycleEnd); + doReturn(intent).when(mController).createManageSubscriptionIntent(mDefaultSubscriptionId); mController.updateState(mSummaryPreference); @@ -161,7 +187,8 @@ public class DataUsageSummaryPreferenceControllerTest { CharSequence value = captor.getValue(); assertThat(value.toString()).isEqualTo("512 MB data warning / 1.00 GB data limit"); - verify(mSummaryPreference).setUsageInfo(info.cycleEnd, now - UPDATE_BACKOFF_MS, + verify(mSummaryPreference).setUsageInfo((info.cycleEnd / 1000) * 1000, + now - UPDATE_BACKOFF_MS, CARRIER_NAME, 1 /* numPlans */, intent); verify(mSummaryPreference).setChartEnabled(true); verify(mSummaryPreference).setWifiMode(false /* isWifiMode */, null /* usagePeriod */, @@ -175,9 +202,8 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); mController.updateState(mSummaryPreference); @@ -186,8 +212,12 @@ public class DataUsageSummaryPreferenceControllerTest { CharSequence value = captor.getValue(); assertThat(value.toString()).isEqualTo("512 MB data warning / 1.00 GB data limit"); - verify(mSummaryPreference).setUsageInfo(info.cycleEnd, now - UPDATE_BACKOFF_MS, - CARRIER_NAME, 0 /* numPlans */, intent); + verify(mSummaryPreference).setUsageInfo( + info.cycleEnd, + -1L /* snapshotTime */, + CARRIER_NAME, + 0 /* numPlans */, + null /* launchIntent */); verify(mSummaryPreference).setChartEnabled(true); verify(mSummaryPreference).setWifiMode(false /* isWifiMode */, null /* usagePeriod */, false /* isSingleWifi */); @@ -198,10 +228,10 @@ public class DataUsageSummaryPreferenceControllerTest { final long now = System.currentTimeMillis(); final DataUsageController.DataUsageInfo info = createTestDataUsageInfo(now); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(null /* carrierName */, -1L /* snapshotTime */, - info.cycleEnd, null /* intent */); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + doReturn(null).when(mSubscriptionInfo).getCarrierName(); + setupTestDataUsage(LIMIT1, USAGE1, -1L /* snapshotTime */); + mController.updateState(mSummaryPreference); ArgumentCaptor captor = ArgumentCaptor.forClass(CharSequence.class); @@ -226,10 +256,10 @@ public class DataUsageSummaryPreferenceControllerTest { final DataUsageController.DataUsageInfo info = createTestDataUsageInfo(now); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, -1L /* dataPlanSize */, USAGE1); - mController.setCarrierValues(null /* carrierName */, -1L /* snapshotTime */, - info.cycleEnd, null /* intent */); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + doReturn(null).when(mSubscriptionInfo).getCarrierName(); + setupTestDataUsage(-1L /* dataPlanSize */, USAGE1, -1L /* snapshotTime */); + mController.updateState(mSummaryPreference); ArgumentCaptor captor = ArgumentCaptor.forClass(CharSequence.class); @@ -256,9 +286,8 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); mController.updateState(mSummaryPreference); verify(mSummaryPreference).setLimitInfo(null); @@ -273,9 +302,8 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); mController.updateState(mSummaryPreference); @@ -294,9 +322,8 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); mController.updateState(mSummaryPreference); @@ -315,9 +342,8 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); mController.updateState(mSummaryPreference); @@ -331,6 +357,11 @@ public class DataUsageSummaryPreferenceControllerTest { @Test public void testSummaryUpdate_noSim_shouldSetWifiMode() { + mController.init(SubscriptionManager.INVALID_SUBSCRIPTION_ID); + mController.mDataUsageController = mDataUsageController; + doReturn(TelephonyManager.SIM_STATE_ABSENT).when(mTelephonyManager).getSimState(); + doReturn(false).when(mController).hasSim(); + final long now = System.currentTimeMillis(); final DataUsageController.DataUsageInfo info = createTestDataUsageInfo(now); info.warningLevel = BillingCycleSettings.MIB_IN_BYTES; @@ -338,11 +369,9 @@ public class DataUsageSummaryPreferenceControllerTest { final Intent intent = new Intent(); - when(mDataUsageController.getDataUsageInfo(any())).thenReturn(info); - mController.setPlanValues(0 /* dataPlanCount */, LIMIT1, USAGE1); - mController.setCarrierValues(CARRIER_NAME, now - UPDATE_BACKOFF_MS, info.cycleEnd, intent); + doReturn(info).when(mDataUsageController).getDataUsageInfo(any()); + setupTestDataUsage(LIMIT1, USAGE1, now - UPDATE_BACKOFF_MS); - when(mTelephonyManager.getSimState()).thenReturn(TelephonyManager.SIM_STATE_ABSENT); mController.updateState(mSummaryPreference); verify(mSummaryPreference).setWifiMode(true /* isWifiMode */, info.period /* usagePeriod */, @@ -355,48 +384,27 @@ public class DataUsageSummaryPreferenceControllerTest { @Test public void testMobileData_preferenceAvailable() { - mController = new DataUsageSummaryPreferenceController( - mDataUsageController, - mDataInfoController, - mNetworkTemplate, - mPolicyEditor, - R.string.cell_data_template, - true, - mSubscriptionManager, - mActivity, null, null, null, mDefaultSubscriptionId); assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @Test public void testMobileData_noSimNoWifi_preferenceDisabled() { - mController = new DataUsageSummaryPreferenceController( - mDataUsageController, - mDataInfoController, - mNetworkTemplate, - mPolicyEditor, - R.string.cell_data_template, - true, - mSubscriptionManager, - mActivity, null, null, null, mDefaultSubscriptionId); - - when(mTelephonyManager.getSimState()).thenReturn(TelephonyManager.SIM_STATE_ABSENT); + final int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + mController.init(subscriptionId); + mController.mDataUsageController = mDataUsageController; + doReturn(TelephonyManager.SIM_STATE_ABSENT).when(mTelephonyManager).getSimState(); + doReturn(false).when(mController).hasSim(); when(mConnectivityManager.isNetworkSupported(TYPE_WIFI)).thenReturn(false); - assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(CONDITIONALLY_UNAVAILABLE); } @Test public void testMobileData_noSimWifi_preferenceDisabled() { - mController = new DataUsageSummaryPreferenceController( - mDataUsageController, - mDataInfoController, - mNetworkTemplate, - mPolicyEditor, - R.string.cell_data_template, - true, - mSubscriptionManager, - mActivity, null, null, null, mDefaultSubscriptionId); - - when(mTelephonyManager.getSimState()).thenReturn(TelephonyManager.SIM_STATE_ABSENT); + final int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + mController.init(subscriptionId); + mController.mDataUsageController = mDataUsageController; + doReturn(TelephonyManager.SIM_STATE_ABSENT).when(mTelephonyManager).getSimState(); when(mConnectivityManager.isNetworkSupported(TYPE_WIFI)).thenReturn(true); assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @@ -405,16 +413,14 @@ public class DataUsageSummaryPreferenceControllerTest { public void testMobileData_entityHeaderSet() { final RecyclerView recyclerView = new RecyclerView(mActivity); - mController = new DataUsageSummaryPreferenceController( + mController = spy(new DataUsageSummaryPreferenceController( mDataUsageController, mDataInfoController, mNetworkTemplate, mPolicyEditor, R.string.cell_data_template, - true, - mSubscriptionManager, mActivity, mLifecycle, mHeaderController, mPreferenceFragment, - mDefaultSubscriptionId); + mDefaultSubscriptionId)); when(mPreferenceFragment.getListView()).thenReturn(recyclerView); @@ -437,4 +443,21 @@ public class DataUsageSummaryPreferenceControllerTest { info.cycleEnd = info.cycleStart + CYCLE_LENGTH_MS; return info; } + + private void setupTestDataUsage(long dataPlanSize, long dataUsageSize, long snapshotTime) { + doReturn(dataPlanSize).when(mSubscriptionPlan).getDataLimitBytes(); + doReturn(dataUsageSize).when(mSubscriptionPlan).getDataUsageBytes(); + doReturn(snapshotTime).when(mSubscriptionPlan).getDataUsageTime(); + + doReturn(dataPlanSize).when(mDataInfoController).getSummaryLimit(any()); + } + + private void createTestDataPlan(long startTime, long endTime) { + final RecurrenceRule recurrenceRule = new RecurrenceRule( + Instant.ofEpochMilli(startTime).atZone(ZoneId.systemDefault()), + Instant.ofEpochMilli(endTime).atZone(ZoneId.systemDefault()), + null); + doReturn(recurrenceRule).when(mSubscriptionPlan).getCycleRule(); + mSubscriptionPlans.add(mSubscriptionPlan); + } }