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

Hide "Changes made by your organization's admin" when empty

Browse Source 
The admin of a manged device can take a number actions that will be
listed in the "Changes made by your organization's admin" section of
Settings. If the admin has not taken any such actions, the section
will be empty and should be hidden. This is accomplished by having a
PreferenceController for the section that observes the state of the
PreferenceControllers inside it.

Bug: 35912953
Test: m RunSettingsRoboTests

Change-Id: Ia95754493ee6c5a19b4aa9731fd56fd558e61849
This commit is contained in:
Bartosz Fabianowski
2017-06-02 10:43:11 +02:00
parent c62ce670c3
commit 55038c0a95
28 changed files with 669 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java
View File

@@ -22,6 +22,7 @@ import android.support.v7.preference.PreferenceScreen;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
@@ -50,6 +51,7 @@ public final class DynamicAvailabilityPreferenceControllerTest {
private @Mock Preference mPreference;
private @Mock PreferenceScreen mScreen;
private @Mock Lifecycle mLifecycle;
private @Mock PreferenceAvailabilityObserver mObserver;
private boolean mIsAvailable;
private Preference mUpdatedPreference = null;
@@ -115,6 +117,21 @@ public final class DynamicAvailabilityPreferenceControllerTest {
assertThat(mUpdatedPreference).isEqualTo(mPreference);
}
@Test
public void testNotifyOnAvailabilityUpdate() {
final DynamicAvailabilityPreferenceController controller
= new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
controller.setAvailabilityObserver(mObserver);
assertThat(controller.getAvailabilityObserver()).isEqualTo(mObserver);
mIsAvailable = false;
controller.isAvailable();
verify(mObserver).onPreferenceAvailabilityUpdated(PREFERENCE_KEY, false);
mIsAvailable = true;
controller.isAvailable();
verify(mObserver).onPreferenceAvailabilityUpdated(PREFERENCE_KEY, true);
}
private class DynamicAvailabilityPreferenceControllerTestable
extends DynamicAvailabilityPreferenceController {
@@ -124,6 +141,7 @@ public final class DynamicAvailabilityPreferenceControllerTest {
@Override
public boolean isAvailable() {
notifyOnAvailabilityUpdate(mIsAvailable);
return mIsAvailable;
}

18
tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java
View File

@@ -21,6 +21,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -32,9 +33,12 @@ import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -48,6 +52,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
protected Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
protected AdminGrantedPermissionsPreferenceControllerBase mController;
@@ -64,6 +69,12 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = createController(true /* async */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
private void setNumberOfPackagesWithAdminGrantedPermissions(int number, boolean async) {
@@ -85,6 +96,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
mController.updateState(preference);
assertThat(preference.isVisible()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
when(mContext.getResources().getQuantityString(
@@ -93,27 +105,33 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo("minimum 20 apps");
assertThat(preference.isVisible()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
}
@Test
public void testIsAvailableSync() {
final AdminGrantedPermissionsPreferenceControllerBase controller
= createController(false /* async */);
controller.setAvailabilityObserver(mObserver);
setNumberOfPackagesWithAdminGrantedPermissions(0, false /* async */);
assertThat(controller.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
setNumberOfPackagesWithAdminGrantedPermissions(20, false /* async */);
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
}
@Test
public void testIsAvailableAsync() {
setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(eq(mKey), anyBoolean());
setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(eq(mKey), anyBoolean());
}
@Test

18
tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceControllerTest.java
View File

@@ -22,6 +22,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -33,6 +34,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -42,12 +44,14 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
private final String VPN_SET_DEVICE = "VPN set";
private final String VPN_SET_PERSONAL = "VPN set in personal profile";
private static final String VPN_SET_DEVICE = "VPN set";
private static final String VPN_SET_PERSONAL = "VPN set in personal profile";
private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private AlwaysOnVpnCurrentUserPreferenceController mController;
@@ -62,6 +66,12 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
.thenReturn(VPN_SET_DEVICE);
when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal))
.thenReturn(VPN_SET_PERSONAL);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -85,10 +95,12 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInCurrentUser())
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_PRIMARY_USER, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInCurrentUser())
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_PRIMARY_USER, true);
}
@Test
@@ -99,6 +111,6 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo("always_on_vpn_primary_user");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_ALWAYS_ON_VPN_PRIMARY_USER);
}
}

15
tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java
View File

@@ -21,6 +21,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -32,6 +33,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -41,9 +43,12 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private AlwaysOnVpnManagedProfilePreferenceController mController;
@@ -54,6 +59,12 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext,
null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -61,10 +72,12 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE, true);
}
@Test
@@ -75,6 +88,6 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo("always_on_vpn_managed_profile");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE);
}
}

15
tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java
View File

@@ -23,6 +23,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -34,6 +35,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -43,9 +45,12 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class CaCertsPreferenceControllerTest {
private static final String KEY_CA_CERTS = "ca_certs";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private CaCertsPreferenceController mController;
@@ -55,6 +60,12 @@ public final class CaCertsPreferenceControllerTest {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new CaCertsPreferenceController(mContext, null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -74,10 +85,12 @@ public final class CaCertsPreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider
.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_CA_CERTS, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider
.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_CA_CERTS, true);
}
@Test
@@ -88,6 +101,6 @@ public final class CaCertsPreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_CA_CERTS);
}
}

29
tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java
View File

@@ -24,6 +24,7 @@ import com.android.settings.R;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -37,9 +38,12 @@ import org.mockito.stubbing.Answer;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.anyObject;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -49,9 +53,13 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class EnterpriseInstalledPackagesPreferenceControllerTest {
private static final String KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES
= "number_enterprise_installed_packages";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterpriseInstalledPackagesPreferenceController mController;
@@ -62,6 +70,12 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterpriseInstalledPackagesPreferenceController(mContext,
null /* lifecycle */, true /* async */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
private void setNumberOfEnterpriseInstalledPackages(int number, boolean async) {
@@ -82,6 +96,8 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
setNumberOfEnterpriseInstalledPackages(0, true /* async */);
mController.updateState(preference);
assertThat(preference.isVisible()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES,
false);
setNumberOfEnterpriseInstalledPackages(20, true /* async */);
when(mContext.getResources().getQuantityString(
@@ -90,6 +106,8 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo("minimum 20 apps");
assertThat(preference.isVisible()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES,
true);
}
@Test
@@ -97,21 +115,30 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
final EnterpriseInstalledPackagesPreferenceController controller
= new EnterpriseInstalledPackagesPreferenceController(mContext,
null /* lifecycle */, false /* async */);
controller.setAvailabilityObserver(mObserver);
setNumberOfEnterpriseInstalledPackages(0, false /* async */);
assertThat(controller.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(
KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES, false);
setNumberOfEnterpriseInstalledPackages(20, false /* async */);
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(
KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES, true);
}
@Test
public void testIsAvailableAsync() {
setNumberOfEnterpriseInstalledPackages(0, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES), anyBoolean());
setNumberOfEnterpriseInstalledPackages(20, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES), anyBoolean());
}
@Test
@@ -123,6 +150,6 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey())
.isEqualTo("number_enterprise_installed_packages");
.isEqualTo(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES);
}
}

21
tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java
View File

@@ -23,6 +23,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -34,6 +35,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -43,13 +45,15 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class EnterprisePrivacyPreferenceControllerTest {
private final String MANAGED_GENERIC = "managed by organization";
private final String MANAGED_WITH_NAME = "managed by Foo, Inc.";
private final String MANAGING_ORGANIZATION = "Foo, Inc.";
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";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterprisePrivacyPreferenceController mController;
@@ -59,6 +63,12 @@ public final class EnterprisePrivacyPreferenceControllerTest {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterprisePrivacyPreferenceController(mContext, null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -85,10 +95,11 @@ public final class EnterprisePrivacyPreferenceControllerTest {
public void testIsAvailable() {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ENTERPRISE_PRIVACY, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ENTERPRISE_PRIVACY, true);
}
@Test
@@ -99,6 +110,6 @@ public final class EnterprisePrivacyPreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo("enterprise_privacy");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_ENTERPRISE_PRIVACY);
}
}

79
tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java
View File

@@ -16,12 +16,16 @@
package com.android.settings.enterprise;
import android.app.Application;
import android.content.Context;
import android.content.res.Resources;
import android.content.res.XmlResourceParser;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceController;
import com.android.settings.testutils.FakeFeatureFactory;
@@ -31,10 +35,14 @@ 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.shadows.ShadowApplication;
import org.xmlpull.v1.XmlPullParser;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
@@ -46,6 +54,9 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class EnterprisePrivacySettingsTest {
private final static String RESOURCES_NAMESPACE = "http://schemas.android.com/apk/res/android";
private final static String ATTR_KEY = "key";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@@ -101,23 +112,24 @@ public final class EnterprisePrivacySettingsTest {
}
@Test
public void getPreferenceControllers() {
public void getPreferenceControllers() throws Exception {
final List<PreferenceController> controllers = mSettings.getPreferenceControllers(
ShadowApplication.getInstance().getApplicationContext());
verifyPreferenceControllers(controllers);
}
@Test
public void getSearchIndexProviderPreferenceControllers() {
public void getSearchIndexProviderPreferenceControllers() throws Exception {
final List<PreferenceController> controllers
= EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers(
ShadowApplication.getInstance().getApplicationContext());
verifyPreferenceControllers(controllers);
}
private void verifyPreferenceControllers(List<PreferenceController> controllers) {
private void verifyPreferenceControllers(List<PreferenceController> controllers)
throws Exception {
assertThat(controllers).isNotNull();
assertThat(controllers.size()).isEqualTo(15);
assertThat(controllers.size()).isEqualTo(16);
int position = 0;
assertThat(controllers.get(position++)).isInstanceOf(NetworkLogsPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(BugReportsPreferenceController.class);
@@ -137,14 +149,71 @@ public final class EnterprisePrivacySettingsTest {
AlwaysOnVpnCurrentUserPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
AlwaysOnVpnManagedProfilePreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(ImePreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
GlobalHttpProxyPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
CaCertsPreferenceController.class);
final PreferenceController exposureChangesCategoryController = controllers.get(position);
final int exposureChangesCategoryControllerIndex = position;
assertThat(controllers.get(position++)).isInstanceOf(
ExposureChangesCategoryPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
FailedPasswordWipeCurrentUserPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
FailedPasswordWipeManagedProfilePreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(ImePreferenceController.class);
// The "Changes made by your organization's admin" category is hidden when all Preferences
// inside it become unavailable. To do this correctly, the category's controller must:
// a) Observe the availability of all Preferences in the category and
// b) Be listed after those Preferences' controllers, so that availability is updated in
// the correct order
// Find all Preferences in the category.
final XmlResourceParser parser = RuntimeEnvironment.application.getResources().getXml(
R.xml.enterprise_privacy_settings);
boolean done = false;
int type;
final Set<String> expectedObserved = new HashSet<>();
while (!done && (type = parser.next()) != XmlPullParser.END_DOCUMENT) {
if (type != XmlPullParser.START_TAG || !"exposure_changes_category".equals(
parser.getAttributeValue(RESOURCES_NAMESPACE, ATTR_KEY))) {
continue;
}
int depth = 1;
while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
if (type == XmlPullParser.START_TAG) {
final String key = parser.getAttributeValue(RESOURCES_NAMESPACE, ATTR_KEY);
if (key != null) {
expectedObserved.add(key);
}
depth++;
} else if (type == XmlPullParser.END_TAG) {
depth--;
if (depth == 0) {
done = true;
break;
}
}
}
}
// Find all Preferences the category's controller is observing.
final Set<String> actualObserved = new HashSet<>();
int maxObservedIndex = -1;
for (int i = 0; i < controllers.size(); i++) {
final PreferenceController controller = controllers.get(i);
if (controller instanceof DynamicAvailabilityPreferenceController &&
((DynamicAvailabilityPreferenceController) controller).getAvailabilityObserver()
== exposureChangesCategoryController) {
actualObserved.add(controller.getPreferenceKey());
maxObservedIndex = i;
}
}
// Verify that the category's controller is observing the Preferences inside it.
assertThat(actualObserved).isEqualTo(expectedObserved);
// Verify that the category's controller is listed after the Preferences' controllers.
assertThat(maxObservedIndex).isLessThan(exposureChangesCategoryControllerIndex);
}
}

16
tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java
View File

@@ -37,6 +37,7 @@ import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.EnterpriseDefaultApps;
import com.android.settings.applications.UserAppInfo;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -51,6 +52,7 @@ import org.robolectric.annotation.Config;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.Mockito.verify;
/**
* Tests for {@link EnterpriseSetDefaultAppsPreferenceController}.
*/
@@ -58,11 +60,14 @@ import java.util.List;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
private static final String KEY_DEFAULT_APPS = "number_enterprise_set_default_apps";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private UserManager mUm;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterpriseSetDefaultAppsPreferenceController mController;
@@ -73,6 +78,12 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterpriseSetDefaultAppsPreferenceController(mContext,
null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
private void setEnterpriseSetDefaultApps(Intent[] intents, int number) {
@@ -119,10 +130,12 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(anyInt(),
any(Intent[].class))).thenReturn(new ArrayList<>());
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_DEFAULT_APPS, false);
setEnterpriseSetDefaultApps(EnterpriseDefaultApps.BROWSER.getIntents(), 1);
configureUsers(1);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_DEFAULT_APPS, true);
}
@Test
@@ -133,8 +146,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey())
.isEqualTo("number_enterprise_set_default_apps");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_DEFAULT_APPS);
}
private ArgumentMatcher<Intent[]> matchesIntents(Intent[] intents) {

192
tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,192 @@
/*
* 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.enterprise;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceAvailabilityObserver;
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.annotation.Config;
import java.util.Arrays;
import java.util.List;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
/**
* Tests for {@link ExposureChangesCategoryPreferenceController}.
*/
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class ExposureChangesCategoryPreferenceControllerTest {
private static final String KEY_1 = "key_1";
private static final String KEY_2 = "key_2";
private static final String KEY_EXPOSURE_CHANGES_CATEGORY = "exposure_changes_category";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private List<DynamicAvailabilityPreferenceController> mControllers;
private ExposureChangesCategoryPreferenceController mController;
@Mock private PreferenceAvailabilityObserver mObserver;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mControllers = Arrays.asList(mock(DynamicAvailabilityPreferenceController.class),
mock(DynamicAvailabilityPreferenceController.class));
mController = new ExposureChangesCategoryPreferenceController(mContext,
null /* lifecycle */, mControllers, true /* controllingUi */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testInitialization() {
verify(mControllers.get(0)).setAvailabilityObserver(mController);
verify(mControllers.get(1)).setAvailabilityObserver(mController);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
public void testOnPreferenceAvailabilityUpdated() {
final Preference preference = new Preference(mContext, null, 0, 0);
preference.setVisible(true);
mController.updateState(preference);
assertThat(preference.isVisible()).isFalse();
mController.onPreferenceAvailabilityUpdated(KEY_1, true);
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
assertThat(preference.isVisible()).isTrue();
reset(mObserver);
mController.onPreferenceAvailabilityUpdated(KEY_2, true);
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
assertThat(preference.isVisible()).isTrue();
reset(mObserver);
mController.onPreferenceAvailabilityUpdated(KEY_1, false);
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
assertThat(preference.isVisible()).isTrue();
reset(mObserver);
mController.onPreferenceAvailabilityUpdated(KEY_2, false);
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
assertThat(preference.isVisible()).isFalse();
}
@Test
public void testUpdateState() {
final Preference preference = new Preference(mContext, null, 0, 0);
preference.setVisible(false);
mController.onPreferenceAvailabilityUpdated(KEY_1, true);
mController.updateState(preference);
assertThat(preference.isVisible()).isTrue();
}
@Test
public void testIsAvailableForUi() {
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
mController.onPreferenceAvailabilityUpdated(KEY_1, true);
reset(mObserver);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
mController.onPreferenceAvailabilityUpdated(KEY_1, false);
reset(mObserver);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
}
@Test
public void testIsAvailableForSearch() {
final ExposureChangesCategoryPreferenceController controller
= new ExposureChangesCategoryPreferenceController(mContext, null /* lifecycle */,
mControllers, false /* controllingUi */);
controller.setAvailabilityObserver(mObserver);
verify(mControllers.get(0)).setAvailabilityObserver(controller);
verify(mControllers.get(1)).setAvailabilityObserver(controller);
assertThat(controller.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
reset(mObserver);
controller.onPreferenceAvailabilityUpdated(KEY_1, true);
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
reset(mObserver);
controller.onPreferenceAvailabilityUpdated(KEY_2, true);
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
reset(mObserver);
controller.onPreferenceAvailabilityUpdated(KEY_1, false);
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
reset(mObserver);
controller.onPreferenceAvailabilityUpdated(KEY_2, false);
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
assertThat(controller.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
}
@Test
public void testHandlePreferenceTreeClick() {
assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0)))
.isFalse();
}
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_EXPOSURE_CHANGES_CATEGORY);
}
}

13
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java
View File

@@ -21,6 +21,7 @@ import android.content.res.Resources;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -30,6 +31,7 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -42,6 +44,7 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
protected Context mContext;
protected FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
protected FailedPasswordWipePreferenceControllerBase mController;
@@ -56,6 +59,12 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
}
@Test
public void testGetAvailabilityObserver() {
mController.setAvailabilityObserver(mObserver);
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
public abstract void setMaximumFailedPasswordsBeforeWipe(int maximum);
@Test
@@ -72,11 +81,15 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
@Test
public void testIsAvailable() {
mController.setAvailabilityObserver(mObserver);
setMaximumFailedPasswordsBeforeWipe(0);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
setMaximumFailedPasswordsBeforeWipe(10);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
}
@Test

16
tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java
View File

@@ -21,6 +21,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -32,6 +33,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -40,9 +42,13 @@ import static org.mockito.Mockito.when;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class GlobalHttpProxyPreferenceControllerTest {
private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private GlobalHttpProxyPreferenceController mController;
@@ -52,6 +58,12 @@ public final class GlobalHttpProxyPreferenceControllerTest {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new GlobalHttpProxyPreferenceController(mContext, null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -59,10 +71,12 @@ public final class GlobalHttpProxyPreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_GLOBAL_HTTP_PROXY, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_GLOBAL_HTTP_PROXY, true);
}
@Test
@@ -73,6 +87,6 @@ public final class GlobalHttpProxyPreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo("global_http_proxy");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_GLOBAL_HTTP_PROXY);
}
}

18
tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java
View File

@@ -23,6 +23,7 @@ import android.support.v7.preference.Preference;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -34,6 +35,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
@@ -43,12 +45,14 @@ import static org.mockito.Mockito.when;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class ImePreferenceControllerTest {
private final String DEFAULT_IME_LABEL = "Test IME";
private final String DEFAULT_IME_TEXT = "Set to Test IME";
private static final String DEFAULT_IME_LABEL = "Test IME";
private static final String DEFAULT_IME_TEXT = "Set to Test IME";
private static final String KEY_INPUT_METHOD = "input_method";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private ImePreferenceController mController;
@@ -60,6 +64,12 @@ public final class ImePreferenceControllerTest {
mController = new ImePreferenceController(mContext, null /* lifecycle */);
when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name,
DEFAULT_IME_LABEL)).thenReturn(DEFAULT_IME_TEXT);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -77,10 +87,12 @@ public final class ImePreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(null);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(DEFAULT_IME_LABEL);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, true);
}
@Test
@@ -91,6 +103,6 @@ public final class ImePreferenceControllerTest {
@Test
public void testGetPreferenceKey() {
assertThat(mController.getPreferenceKey()).isEqualTo("input_method");
assertThat(mController.getPreferenceKey()).isEqualTo(KEY_INPUT_METHOD);
}
}