From 90684812999d612b1fa80fed9aad8a279029ab12 Mon Sep 17 00:00:00 2001 From: Salud Lemus Date: Mon, 12 Apr 2021 15:50:59 -0700 Subject: [PATCH] Fix search index for a financed device Now with two preference controllers, one for enterprise device and one for financed device, the search index issue (querying "Financed device info" in Settings does not show a search result) is fixed. The financed preference controller is used when the device is a financed device. Otherwise, the enterprise preference controller is used. Bug: 183551684 Test: Used a test device that is registered via ZT Test: m RunSettingsRoboTests ROBOTEST_FILTER=EnterprisePrivacyPreferenceControllerTest Test: m RunSettingsRoboTests ROBOTEST_FILTER=FinancedPrivacyPreferenceControllerTest Test: m RunSettingsRoboTests ROBOTEST_FILTER=PrivacyPreferenceControllerHelperTest Change-Id: I051144ec9004f86456285078ebb1c72266f80a55 --- res/xml/security_dashboard_settings.xml | 6 + ...EnterprisePrivacyPreferenceController.java | 46 +++--- .../FinancedPrivacyPreferenceController.java | 62 ++++++++ .../PrivacyPreferenceControllerHelper.java | 70 +++++++++ .../settings/security/SecuritySettings.java | 2 + ...rprisePrivacyPreferenceControllerTest.java | 81 +++-------- ...nancedPrivacyPreferenceControllerTest.java | 87 +++++++++++ ...PrivacyPreferenceControllerHelperTest.java | 135 ++++++++++++++++++ 8 files changed, 399 insertions(+), 90 deletions(-) create mode 100644 src/com/android/settings/enterprise/FinancedPrivacyPreferenceController.java create mode 100644 src/com/android/settings/enterprise/PrivacyPreferenceControllerHelper.java create mode 100644 tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java create mode 100644 tests/robotests/src/com/android/settings/enterprise/PrivacyPreferenceControllerHelperTest.java diff --git a/res/xml/security_dashboard_settings.xml b/res/xml/security_dashboard_settings.xml index 1b7b02654c2..fd9f3186996 100644 --- a/res/xml/security_dashboard_settings.xml +++ b/res/xml/security_dashboard_settings.xml @@ -111,6 +111,12 @@ android:summary="@string/summary_placeholder" android:fragment="com.android.settings.enterprise.EnterprisePrivacySettings" /> + + controllers = new ArrayList<>(); controllers.add(new EnterprisePrivacyPreferenceController(context)); + controllers.add(new FinancedPrivacyPreferenceController(context)); controllers.add(new ManageTrustAgentsPreferenceController(context)); controllers.add(new ScreenPinningPreferenceController(context)); controllers.add(new SimLockPreferenceController(context)); diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java index 80523573011..2bac8f1cebb 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java @@ -16,22 +16,15 @@ package com.android.settings.enterprise; -import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_DEFAULT; -import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_FINANCED; - import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import android.app.admin.DevicePolicyManager; -import android.content.ComponentName; import android.content.Context; import androidx.preference.Preference; -import com.android.settings.R; -import com.android.settings.testutils.FakeFeatureFactory; - import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -43,82 +36,50 @@ import org.robolectric.RobolectricTestRunner; @RunWith(RobolectricTestRunner.class) public class EnterprisePrivacyPreferenceControllerTest { - private static final String MANAGED_GENERIC = "managed by organization"; - private static final String MANAGED_WITH_NAME = "managed by Foo, Inc."; - private static final String MANAGING_ORGANIZATION = "Foo, Inc."; private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy"; - private static final String FINANCED_PREFERENCE_TITLE = "Financed device info"; - private static final ComponentName DEVICE_OWNER_COMPONENT = - new ComponentName("com.android.foo", "bar"); @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; @Mock - private DevicePolicyManager mDevicePolicyManager; - private FakeFeatureFactory mFeatureFactory; - + private PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper; private EnterprisePrivacyPreferenceController mController; @Before public void setUp() { MockitoAnnotations.initMocks(this); - mFeatureFactory = FakeFeatureFactory.setupForTest(); - mController = new EnterprisePrivacyPreferenceController(mContext); - - when((Object) mContext.getSystemService(DevicePolicyManager.class)) - .thenReturn(mDevicePolicyManager); - when(mDevicePolicyManager.isDeviceManaged()).thenReturn(true); - when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser()) - .thenReturn(DEVICE_OWNER_COMPONENT); - when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT)) - .thenReturn(DEVICE_OWNER_TYPE_DEFAULT); + mController = new EnterprisePrivacyPreferenceController( + mContext, mPrivacyPreferenceControllerHelper); } @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - when(mContext.getString(R.string.enterprise_privacy_settings_summary_generic)) - .thenReturn(MANAGED_GENERIC); - when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName()) - .thenReturn(null); mController.updateState(preference); - assertThat(preference.getSummary()).isEqualTo(MANAGED_GENERIC); - when(mContext.getResources().getString( - R.string.enterprise_privacy_settings_summary_with_name, MANAGING_ORGANIZATION)) - .thenReturn(MANAGED_WITH_NAME); - when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName()) - .thenReturn(MANAGING_ORGANIZATION); - mController.updateState(preference); - assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME); + verify(mPrivacyPreferenceControllerHelper).updateState(preference); } @Test - public void testUpdateState_verifyPreferenceTitleIsUpdatedForFinancedDevice() { - final Preference preference = new Preference(mContext, null, 0, 0); - when(mContext.getResources().getString( - R.string.enterprise_privacy_settings_summary_with_name, MANAGING_ORGANIZATION)) - .thenReturn(MANAGED_WITH_NAME); - when(mContext.getString(R.string.financed_privacy_settings)) - .thenReturn(FINANCED_PREFERENCE_TITLE); - when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName()) - .thenReturn(MANAGING_ORGANIZATION); - when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT)) - .thenReturn(DEVICE_OWNER_TYPE_FINANCED); + public void testIsAvailable_noDeviceOwner_returnsFalse() { + when(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).thenReturn(false); - mController.updateState(preference); - - assertThat(preference.getTitle()).isEqualTo(FINANCED_PREFERENCE_TITLE); - assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME); - } - - @Test - public void testIsAvailable() { - when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false); assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void testIsAvailable_deviceOwner_financedDevice_returnsFalse() { + when(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).thenReturn(true); + when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(true); + + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void testIsAvailable_deviceOwner_enterpriseDevice_returnsTrue() { + when(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).thenReturn(true); + when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(false); - when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true); assertThat(mController.isAvailable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java new file mode 100644 index 00000000000..f8adf6fb6e2 --- /dev/null +++ b/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2021 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.enterprise; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; + +import androidx.preference.Preference; + +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.RobolectricTestRunner; + +@RunWith(RobolectricTestRunner.class) +public class FinancedPrivacyPreferenceControllerTest { + + private static final String PREF_KEY_FINANCED_PRIVACY = "financed_privacy"; + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + @Mock + private PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper; + private FinancedPrivacyPreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mController = new FinancedPrivacyPreferenceController( + mContext, mPrivacyPreferenceControllerHelper); + } + + @Test + public void testUpdateState() { + final Preference preference = new Preference(mContext, null, 0, 0); + + mController.updateState(preference); + + verify(mPrivacyPreferenceControllerHelper).updateState(preference); + } + + @Test + public void testIsAvailable_financedDevice_returnsTrue() { + when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(true); + + assertThat(mController.isAvailable()).isTrue(); + } + + @Test + public void testIsAvailable_enterpriseDevice_returnsFalse() { + when(mPrivacyPreferenceControllerHelper.isFinancedDevice()).thenReturn(false); + + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void testHandlePreferenceTreeClick() { + assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0))) + .isFalse(); + } + + @Test + public void testGetPreferenceKey() { + assertThat(mController.getPreferenceKey()).isEqualTo(PREF_KEY_FINANCED_PRIVACY); + } +} diff --git a/tests/robotests/src/com/android/settings/enterprise/PrivacyPreferenceControllerHelperTest.java b/tests/robotests/src/com/android/settings/enterprise/PrivacyPreferenceControllerHelperTest.java new file mode 100644 index 00000000000..cbd6392e568 --- /dev/null +++ b/tests/robotests/src/com/android/settings/enterprise/PrivacyPreferenceControllerHelperTest.java @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2021 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.enterprise; + +import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_DEFAULT; +import static android.app.admin.DevicePolicyManager.DEVICE_OWNER_TYPE_FINANCED; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.when; + +import android.app.admin.DevicePolicyManager; +import android.content.ComponentName; +import android.content.Context; + +import androidx.preference.Preference; + +import com.android.settings.R; +import com.android.settings.testutils.FakeFeatureFactory; + +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.RobolectricTestRunner; + +@RunWith(RobolectricTestRunner.class) +public class PrivacyPreferenceControllerHelperTest { + + private static final String MANAGED_GENERIC = "managed by organization"; + private static final String MANAGED_WITH_NAME = "managed by Foo, Inc."; + private static final String MANAGING_ORGANIZATION = "Foo, Inc."; + private static final ComponentName DEVICE_OWNER_COMPONENT = + new ComponentName("com.android.foo", "bar"); + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + @Mock + private DevicePolicyManager mDevicePolicyManager; + private FakeFeatureFactory mFeatureFactory; + private PrivacyPreferenceControllerHelper mPrivacyPreferenceControllerHelper; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mFeatureFactory = FakeFeatureFactory.setupForTest(); + + when((Object) mContext.getSystemService(DevicePolicyManager.class)) + .thenReturn(mDevicePolicyManager); + mPrivacyPreferenceControllerHelper = new PrivacyPreferenceControllerHelper(mContext); + + when(mDevicePolicyManager.isDeviceManaged()).thenReturn(true); + when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser()) + .thenReturn(DEVICE_OWNER_COMPONENT); + when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT)) + .thenReturn(DEVICE_OWNER_TYPE_DEFAULT); + } + + @Test + public void testUpdateState_noDeviceOwnerName_useGenericPreferenceSummary() { + final Preference preference = new Preference(mContext, null, 0, 0); + when(mContext.getString(R.string.enterprise_privacy_settings_summary_generic)) + .thenReturn(MANAGED_GENERIC); + when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName()) + .thenReturn(null); + + mPrivacyPreferenceControllerHelper.updateState(preference); + + assertThat(preference.getSummary().toString()).isEqualTo(MANAGED_GENERIC); + } + + @Test + public void testUpdateState_deviceOwnerName_usePreferenceSummaryWithDeviceOwnerName() { + final Preference preference = new Preference(mContext, null, 0, 0); + when(mContext.getResources().getString( + R.string.enterprise_privacy_settings_summary_with_name, MANAGING_ORGANIZATION)) + .thenReturn(MANAGED_WITH_NAME); + when(mFeatureFactory.enterprisePrivacyFeatureProvider.getDeviceOwnerOrganizationName()) + .thenReturn(MANAGING_ORGANIZATION); + + mPrivacyPreferenceControllerHelper.updateState(preference); + + assertThat(preference.getSummary().toString()).isEqualTo(MANAGED_WITH_NAME); + } + + @Test + public void hasDeviceOwner_deviceOwner_returnsTrue() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true); + + assertThat(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).isTrue(); + } + + @Test + public void hasDeviceOwner_noDeviceOwner_returnsFalse() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false); + + assertThat(mPrivacyPreferenceControllerHelper.hasDeviceOwner()).isFalse(); + } + + @Test + public void isFinancedDevice_deviceNotManaged_returnsFalse() { + when(mDevicePolicyManager.isDeviceManaged()).thenReturn(false); + + assertThat(mPrivacyPreferenceControllerHelper.isFinancedDevice()).isFalse(); + } + + @Test + public void isFinancedDevice_deviceManaged_defaultDeviceOwnerType_returnsFalse() { + assertThat(mPrivacyPreferenceControllerHelper.isFinancedDevice()).isFalse(); + } + + @Test + public void isFinancedDevice_deviceManaged_financedDeviceOwnerType_returnsTrue() { + when(mDevicePolicyManager.getDeviceOwnerType(DEVICE_OWNER_COMPONENT)) + .thenReturn(DEVICE_OWNER_TYPE_FINANCED); + + assertThat(mPrivacyPreferenceControllerHelper.isFinancedDevice()).isTrue(); + } +}