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

Remove data usage v1 code.

Browse Source 
- remove all v1 code and the corresponding feature flag switch.

Bug: 117420679
Test: make RunSettingsRoboTests
Change-Id: Ib062c03c671b0f860698f5e5e153ab46d963175a
This commit is contained in:
Doris Ling
2018-11-30 13:00:42 -08:00
parent 859017e99a
commit c11666cc00
26 changed files with 93 additions and 1836 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java
View File

@@ -1,175 +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.datausage;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
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.verify;
import static org.mockito.Mockito.when;
import android.content.pm.PackageManager;
import android.net.NetworkPolicyManager;
import android.os.Bundle;
import android.util.ArraySet;
import android.view.View;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowEntityHeaderController;
import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
import com.android.settings.widget.EntityHeaderController;
import com.android.settingslib.AppItem;
import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
import com.android.settingslib.RestrictedSwitchPreference;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {ShadowEntityHeaderController.class, ShadowRestrictedLockUtilsInternal.class})
public class AppDataUsageTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private EntityHeaderController mHeaderController;
@Mock
private PackageManager mPackageManager;
private AppDataUsage mFragment;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest();
}
@After
public void tearDown() {
ShadowEntityHeaderController.reset();
}
@Test
public void bindAppHeader_allWorkApps_shouldNotShowAppInfoLink() {
ShadowEntityHeaderController.setUseMock(mHeaderController);
when(mHeaderController.setRecyclerView(any(), any())).thenReturn(mHeaderController);
when(mHeaderController.setUid(anyInt())).thenReturn(mHeaderController);
mFragment = spy(new AppDataUsage());
when(mFragment.getPreferenceManager())
.thenReturn(mock(PreferenceManager.class, RETURNS_DEEP_STUBS));
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
ReflectionHelpers.setField(mFragment, "mAppItem", mock(AppItem.class));
mFragment.onViewCreated(new View(RuntimeEnvironment.application), new Bundle());
verify(mHeaderController).setHasAppInfoLink(false);
}
@Test
public void bindAppHeader_workApp_shouldSetWorkAppUid() throws
PackageManager.NameNotFoundException {
final int fakeUserId = 100;
mFragment = spy(new AppDataUsage());
final ArraySet<String> packages = new ArraySet<>();
packages.add("pkg");
final AppItem appItem = new AppItem(123456789);
ReflectionHelpers.setField(mFragment, "mPackageManager", mPackageManager);
ReflectionHelpers.setField(mFragment, "mAppItem", appItem);
ReflectionHelpers.setField(mFragment, "mPackages", packages);
when(mPackageManager.getPackageUidAsUser(anyString(), anyInt()))
.thenReturn(fakeUserId);
ShadowEntityHeaderController.setUseMock(mHeaderController);
when(mHeaderController.setRecyclerView(any(), any())).thenReturn(mHeaderController);
when(mHeaderController.setUid(fakeUserId)).thenReturn(mHeaderController);
when(mHeaderController.setHasAppInfoLink(anyBoolean())).thenReturn(mHeaderController);
when(mFragment.getPreferenceManager())
.thenReturn(mock(PreferenceManager.class, RETURNS_DEEP_STUBS));
doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen();
mFragment.onViewCreated(new View(RuntimeEnvironment.application), new Bundle());
verify(mHeaderController).setHasAppInfoLink(true);
verify(mHeaderController).setUid(fakeUserId);
}
@Test
public void changePreference_backgroundData_shouldUpdateUI() {
mFragment = spy(new AppDataUsage());
final AppItem appItem = new AppItem(123456789);
final RestrictedSwitchPreference pref = mock(RestrictedSwitchPreference.class);
final DataSaverBackend dataSaverBackend = mock(DataSaverBackend.class);
ReflectionHelpers.setField(mFragment, "mAppItem", appItem);
ReflectionHelpers.setField(mFragment, "mRestrictBackground", pref);
ReflectionHelpers.setField(mFragment, "mDataSaverBackend", dataSaverBackend);
doNothing().when(mFragment).updatePrefs();
mFragment.onPreferenceChange(pref, true /* value */);
verify(mFragment).updatePrefs();
}
@Test
public void updatePrefs_restrictedByAdmin_shouldDisablePreference() {
mFragment = spy(new AppDataUsage());
final int testUid = 123123;
final AppItem appItem = new AppItem(testUid);
final RestrictedSwitchPreference restrictBackgroundPref
= mock(RestrictedSwitchPreference.class);
final RestrictedSwitchPreference unrestrictedDataPref
= mock(RestrictedSwitchPreference.class);
final DataSaverBackend dataSaverBackend = mock(DataSaverBackend.class);
final NetworkPolicyManager networkPolicyManager = mock(NetworkPolicyManager.class);
ReflectionHelpers.setField(mFragment, "mAppItem", appItem);
ReflectionHelpers.setField(mFragment, "mRestrictBackground", restrictBackgroundPref);
ReflectionHelpers.setField(mFragment, "mUnrestrictedData", unrestrictedDataPref);
ReflectionHelpers.setField(mFragment, "mDataSaverBackend", dataSaverBackend);
ReflectionHelpers.setField(mFragment.services, "mPolicyManager", networkPolicyManager);
ShadowRestrictedLockUtilsInternal.setRestricted(true);
doReturn(NetworkPolicyManager.POLICY_NONE).when(networkPolicyManager)
.getUidPolicy(testUid);
mFragment.updatePrefs();
verify(restrictBackgroundPref).setDisabledByAdmin(any(EnforcedAdmin.class));
verify(unrestrictedDataPref).setDisabledByAdmin(any(EnforcedAdmin.class));
}
}

90
tests/robotests/src/com/android/settings/datausage/ChartDataUsagePreferenceTest.java
View File

@@ -18,17 +18,15 @@ package com.android.settings.datausage;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
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.NetworkStatsHistory;
import android.net.NetworkStatsHistory.Entry;
import android.util.SparseIntArray;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.widget.UsageView;
import com.android.settingslib.net.NetworkCycleChartData;
import com.android.settingslib.net.NetworkCycleData;
import org.junit.Before;
import org.junit.Test;
@@ -37,14 +35,17 @@ import org.mockito.ArgumentCaptor;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import java.util.ArrayList;
import java.util.List;
@RunWith(SettingsRobolectricTestRunner.class)
public class ChartDataUsagePreferenceTest {
private static final long MILLIS_IN_ONE_HOUR = 60 * 60 * 1000;
private static final long MILLIS_IN_ONE_DAY = 24 * MILLIS_IN_ONE_HOUR;
private static final long TIMESTAMP_NOW = Integer.MAX_VALUE;
private static final long TIMESTAMP_START = 1521583200000L;
private static final long TIMESTAMP_END = 1521676800000L;
private NetworkStatsHistory mNetworkStatsHistory;
private List<NetworkCycleData> mNetworkCycleData;
private NetworkCycleChartData mNetworkCycleChartData;
private Context mContext;
private ChartDataUsagePreference mPreference;
@@ -54,23 +55,17 @@ public class ChartDataUsagePreferenceTest {
mContext = RuntimeEnvironment.application;
mPreference = new ChartDataUsagePreference(mContext, null);
mNetworkStatsHistory = spy(new NetworkStatsHistory(MILLIS_IN_ONE_HOUR, 10));
addTestNetworkEntries();
mPreference.setNetworkStats(mNetworkStatsHistory);
createTestNetworkData();
mPreference.setNetworkCycleData(mNetworkCycleChartData);
}
@Test
public void calcPoints_notStartOfData_shouldAddDataPointsOnly() {
final long start = TIMESTAMP_NOW - 20 * MILLIS_IN_ONE_DAY;
final long end = TIMESTAMP_NOW - 5 * MILLIS_IN_ONE_DAY;
mPreference.setVisibleRange(start, end);
when(mNetworkStatsHistory.getIndexAfter(start)).thenReturn(2);
when(mNetworkStatsHistory.getIndexAfter(end)).thenReturn(7);
public void calcPoints_dataAvailableFromCycleStart_shouldAddDataPointsOnly() {
final UsageView usageView = mock(UsageView.class);
final ArgumentCaptor<SparseIntArray> pointsCaptor =
ArgumentCaptor.forClass(SparseIntArray.class);
mPreference.calcPoints(usageView);
mPreference.calcPoints(usageView, mNetworkCycleData.subList(0, 5));
verify(usageView).addPath(pointsCaptor.capture());
SparseIntArray points = pointsCaptor.getValue();
@@ -79,17 +74,12 @@ public class ChartDataUsagePreferenceTest {
}
@Test
public void calcPoints_startOfData_shouldIndicateStartOfData() {
final long start = TIMESTAMP_NOW - 20 * MILLIS_IN_ONE_DAY;
final long end = TIMESTAMP_NOW - 5 * MILLIS_IN_ONE_DAY;
mPreference.setVisibleRange(start, end);
when(mNetworkStatsHistory.getIndexAfter(start)).thenReturn(0);
when(mNetworkStatsHistory.getIndexAfter(end)).thenReturn(5);
public void calcPoints_dataNotAvailableAtCycleStart_shouldIndicateStartOfData() {
final UsageView usageView = mock(UsageView.class);
final ArgumentCaptor<SparseIntArray> pointsCaptor =
ArgumentCaptor.forClass(SparseIntArray.class);
mPreference.calcPoints(usageView);
mPreference.calcPoints(usageView, mNetworkCycleData.subList(2, 7));
verify(usageView).addPath(pointsCaptor.capture());
SparseIntArray points = pointsCaptor.getValue();
@@ -98,35 +88,29 @@ public class ChartDataUsagePreferenceTest {
assertThat(points.valueAt(1)).isEqualTo(-1);
}
private void addTestNetworkEntries() {
// create 10 arbitary network data
mNetworkStatsHistory.setValues(0, createEntry(1521583200000L, 743823454L, 16574289L));
mNetworkStatsHistory.setValues(1, createEntry(1521586800000L, 64396L, 160364L));
mNetworkStatsHistory.setValues(2, createEntry(1521590400000L, 2832L, 5299L));
mNetworkStatsHistory.setValues(3, createEntry(1521655200000L, 83849690L, 3558238L));
mNetworkStatsHistory.setValues(4, createEntry(1521658800000L, 1883657L, 353330L));
mNetworkStatsHistory.setValues(5, createEntry(1521662400000L, 705259L, 279065L));
mNetworkStatsHistory.setValues(6, createEntry(1521666000000L, 216169L, 155302L));
mNetworkStatsHistory.setValues(7, createEntry(1521669600000L, 6069175L, 427581L));
mNetworkStatsHistory.setValues(8, createEntry(1521673200000L, 120389L, 110807L));
mNetworkStatsHistory.setValues(9, createEntry(1521676800000L, 29947L, 73257L));
private void createTestNetworkData() {
mNetworkCycleData = new ArrayList<>();
// create 10 arbitrary network data
mNetworkCycleData.add(createNetworkCycleData(1521583200000L, 1521586800000L, 743823454L));
mNetworkCycleData.add(createNetworkCycleData(1521586800000L, 1521590400000L, 64396L));
mNetworkCycleData.add(createNetworkCycleData(1521590400000L, 1521655200000L, 2832L));
mNetworkCycleData.add(createNetworkCycleData(1521655200000L, 1521658800000L, 83849690L));
mNetworkCycleData.add(createNetworkCycleData(1521658800000L, 1521662400000L, 1883657L));
mNetworkCycleData.add(createNetworkCycleData(1521662400000L, 1521666000000L, 705259L));
mNetworkCycleData.add(createNetworkCycleData(1521666000000L, 1521669600000L, 216169L));
mNetworkCycleData.add(createNetworkCycleData(1521669600000L, 1521673200000L, 6069175L));
mNetworkCycleData.add(createNetworkCycleData(1521673200000L, 1521676800000L, 120389L));
mNetworkCycleData.add(createNetworkCycleData(1521676800000L, 1521678800000L, 29947L));
final NetworkCycleChartData.Builder builder = new NetworkCycleChartData.Builder();
builder.setUsageBuckets(mNetworkCycleData)
.setStartTime(TIMESTAMP_START)
.setEndTime(TIMESTAMP_END);
mNetworkCycleChartData = builder.build();
}
/**
* Create a network entry to be used to calculate the usage chart. In the calculation, we only
* need bucketStart, total bytes (rx + tx), and bucketDuration (which is set when we create
* the NetworkStatsHistory object). Other fields are ignored, so we don't initialize here.
*
* @param start the timestamp when this entry begins
* @param rx the total number of received bytes
* @param tx the total number of transmitted bytes
* @return the network entry with the corresponding start time and data usage
*/
private Entry createEntry(long start, long rx, long tx) {
Entry entry = new Entry();
entry.bucketStart = start;
entry.rxBytes = rx;
entry.txBytes = tx;
return entry;
private NetworkCycleData createNetworkCycleData(long start, long end, long usage) {
return new NetworkCycleData.Builder()
.setStartTime(start).setEndTime(end).setTotalUsage(usage).build();
}
}

114
tests/robotests/src/com/android/settings/datausage/DataUsageListTest.java
View File

@@ -1,114 +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.datausage;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.Intent;
import android.net.NetworkTemplate;
import android.os.Bundle;
import android.provider.Settings;
import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceManager;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.NetworkPolicyEditor;
import com.android.settingslib.core.instrumentation.VisibilityLoggerMixin;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.util.ReflectionHelpers;
@RunWith(SettingsRobolectricTestRunner.class)
public class DataUsageListTest {
@Mock
private CellDataPreference.DataStateListener mListener;
@Mock
private TemplatePreference.NetworkServices mNetworkServices;
@Mock
private Context mContext;
private DataUsageList mDataUsageList;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest();
mNetworkServices.mPolicyEditor = mock(NetworkPolicyEditor.class);
mDataUsageList = spy(DataUsageList.class);
doReturn(mContext).when(mDataUsageList).getContext();
ReflectionHelpers.setField(mDataUsageList, "mDataStateListener", mListener);
ReflectionHelpers.setField(mDataUsageList, "services", mNetworkServices);
}
@Test
public void resumePause_shouldListenUnlistenDataStateChange() {
ReflectionHelpers.setField(
mDataUsageList, "mVisibilityLoggerMixin", mock(VisibilityLoggerMixin.class));
ReflectionHelpers.setField(
mDataUsageList, "mPreferenceManager", mock(PreferenceManager.class));
mDataUsageList.onResume();
verify(mListener).setListener(true, mDataUsageList.mSubId, mContext);
mDataUsageList.onPause();
verify(mListener).setListener(false, mDataUsageList.mSubId, mContext);
}
@Test
public void processArgument_shouldGetTemplateFromArgument() {
final Bundle args = new Bundle();
args.putParcelable(DataUsageList.EXTRA_NETWORK_TEMPLATE, mock(NetworkTemplate.class));
args.putInt(DataUsageList.EXTRA_SUB_ID, 3);
mDataUsageList.setArguments(args);
mDataUsageList.processArgument();
assertThat(mDataUsageList.mTemplate).isNotNull();
assertThat(mDataUsageList.mSubId).isEqualTo(3);
}
@Test
public void processArgument_fromIntent_shouldGetTemplateFromIntent() {
final FragmentActivity activity = mock(FragmentActivity.class);
final Intent intent = new Intent();
intent.putExtra(Settings.EXTRA_NETWORK_TEMPLATE, mock(NetworkTemplate.class));
intent.putExtra(Settings.EXTRA_SUB_ID, 3);
when(activity.getIntent()).thenReturn(intent);
doReturn(activity).when(mDataUsageList).getActivity();
mDataUsageList.processArgument();
assertThat(mDataUsageList.mTemplate).isNotNull();
assertThat(mDataUsageList.mSubId).isEqualTo(3);
}
}

4
tests/robotests/src/com/android/settings/datausage/DataUsageSummaryPreferenceTest.java
View File

@@ -513,11 +513,11 @@ public class DataUsageSummaryPreferenceTest {
SubSettings.class.getName()));
final Bundle expect = new Bundle(1);
expect.putParcelable(DataUsageList.EXTRA_NETWORK_TEMPLATE,
expect.putParcelable(DataUsageListV2.EXTRA_NETWORK_TEMPLATE,
NetworkTemplate.buildTemplateWifiWildcard());
final Bundle actual = startedIntent
.getBundleExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS);
assertThat((NetworkTemplate) actual.getParcelable(DataUsageList.EXTRA_NETWORK_TEMPLATE))
assertThat((NetworkTemplate) actual.getParcelable(DataUsageListV2.EXTRA_NETWORK_TEMPLATE))
.isEqualTo(NetworkTemplate.buildTemplateWifiWildcard());
assertThat(startedIntent.getIntExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, 0))

3
tests/robotests/src/com/android/settings/datausage/DataUsageUtilsTest.java
View File

@@ -29,9 +29,7 @@ import android.content.Context;
import android.net.ConnectivityManager;
import android.telephony.TelephonyManager;
import android.util.DataUnit;
import android.util.FeatureFlagUtils;
import com.android.settings.core.FeatureFlags;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
@@ -102,7 +100,6 @@ public final class DataUsageUtilsTest {
@Test
public void hasEthernet_shouldQueryEthernetSummaryForUser() throws Exception {
FeatureFlagUtils.setEnabled(mContext, FeatureFlags.DATA_USAGE_V2, true);
when(mManager.isNetworkSupported(anyInt())).thenReturn(true);
final String subscriber = "TestSub";
when(mTelephonyManager.getSubscriberId()).thenReturn(subscriber);