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

Merge "Remove DynamicAvailabilityPreferenceController."

Browse Source
This commit is contained in:
TreeHugger Robot
2017-11-08 02:26:16 +00:00
committed by Android (Google) Code Review
parent 07e63ea23d b5f5ffbece
commit d85cd117c8
46 changed files with 202 additions and 1048 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,157 +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.core;
import android.content.Context;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link DynamicAvailabilityPreferenceController}.
*/
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class DynamicAvailabilityPreferenceControllerTest {
private final String PREFERENCE_KEY = "preference_key";
private @Mock Context mContext;
private @Mock Preference mPreference;
private @Mock PreferenceScreen mScreen;
private @Mock Lifecycle mLifecycle;
private @Mock PreferenceAvailabilityObserver mObserver;
private boolean mIsAvailable;
private Preference mUpdatedPreference = null;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
when(mPreference.getKey()).thenReturn(PREFERENCE_KEY);
when(mScreen.findPreference(PREFERENCE_KEY)).thenReturn(mPreference);
when(mScreen.getPreferenceCount()).thenReturn(1);
when(mScreen.getPreference(0)).thenReturn(mPreference);
}
@Test
public void testAvailableToUnavailable() {
mIsAvailable = true;
final DynamicAvailabilityPreferenceController controller
= new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
verify(mLifecycle).addObserver(controller);
controller.displayPreference(mScreen);
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
controller.onResume();
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isEqualTo(mPreference);
mUpdatedPreference = null;
mIsAvailable = false;
controller.onResume();
verify(mScreen).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
}
@Test
public void testUnavailableToAvailable() {
mIsAvailable = false;
final DynamicAvailabilityPreferenceController controller
= new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
verify(mLifecycle).addObserver(controller);
controller.displayPreference(mScreen);
verify(mScreen).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
reset(mScreen);
controller.onResume();
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
mIsAvailable = true;
controller.onResume();
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen).addPreference(mPreference);
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 {
public DynamicAvailabilityPreferenceControllerTestable(Lifecycle lifecycle) {
super(DynamicAvailabilityPreferenceControllerTest.this.mContext, lifecycle);
}
@Override
public boolean isAvailable() {
notifyOnAvailabilityUpdate(mIsAvailable);
return mIsAvailable;
}
@Override
public void updateState(Preference preference) {
mUpdatedPreference = preference;
}
@Override
public String getPreferenceKey() {
return PREFERENCE_KEY;
}
}
}

6
tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java
View File

@@ -34,13 +34,11 @@ public final class AdminGrantedCameraPermissionPreferenceControllerTest extends
public AdminGrantedCameraPermissionPreferenceControllerTest() {
super("enterprise_privacy_number_camera_access_packages",
new String[] {Manifest.permission.CAMERA},
Manifest.permission_group.CAMERA);
new String[] {Manifest.permission.CAMERA});
}
@Override
protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
return new AdminGrantedCameraPermissionPreferenceController(mContext,null /* lifecycle */,
async);
return new AdminGrantedCameraPermissionPreferenceController(mContext, async);
}
}

8
tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java
View File

@@ -18,8 +18,8 @@ package com.android.settings.enterprise;
import android.Manifest;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -35,13 +35,11 @@ public final class AdminGrantedLocationPermissionsPreferenceControllerTest exten
public AdminGrantedLocationPermissionsPreferenceControllerTest() {
super("enterprise_privacy_number_location_access_packages",
new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.ACCESS_FINE_LOCATION},
Manifest.permission_group.LOCATION);
Manifest.permission.ACCESS_FINE_LOCATION});
}
@Override
protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
return new AdminGrantedLocationPermissionsPreferenceController(mContext,
null /* lifecycle */, async);
return new AdminGrantedLocationPermissionsPreferenceController(mContext, async);
}
}

8
tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java
View File

@@ -18,8 +18,8 @@ package com.android.settings.enterprise;
import android.Manifest;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -34,13 +34,11 @@ public final class AdminGrantedMicrophonePermissionPreferenceControllerTest exte
public AdminGrantedMicrophonePermissionPreferenceControllerTest() {
super("enterprise_privacy_number_microphone_access_packages",
new String[] {Manifest.permission.RECORD_AUDIO},
Manifest.permission_group.MICROPHONE);
new String[] {Manifest.permission.RECORD_AUDIO});
}
@Override
protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
return new AdminGrantedMicrophonePermissionPreferenceController(mContext,
null /* lifecycle */, async);
return new AdminGrantedMicrophonePermissionPreferenceController(mContext, async);
}
}

6
tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java
View File

@@ -16,8 +16,8 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -31,7 +31,7 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends
AdminGrantedPermissionsPreferenceControllerTestBase {
public AdminGrantedPermissionsPreferenceControllerBaseTest() {
super("some.key", new String[] {"some.permission"}, "some.permission");
super("some.key", new String[] {"some.permission"});
}
@Override
@@ -44,7 +44,7 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends
AdminGrantedPermissionsPreferenceControllerBaseTestable(boolean async) {
super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext,
null /* lifecycle */, async, mPermissions, mPermissionGroup);
async, mPermissions);
}
@Override

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

@@ -16,12 +16,17 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.when;
import android.content.Context;
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,35 +37,22 @@ import org.mockito.MockitoAnnotations;
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;
/**
* Common base for testing subclasses of {@link AdminGrantedPermissionsPreferenceControllerBase}.
*/
public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
protected final String mKey;
protected final String[] mPermissions;
protected final String mPermissionGroup;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
protected Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
protected AdminGrantedPermissionsPreferenceControllerBase mController;
public AdminGrantedPermissionsPreferenceControllerTestBase(String key, String[] permissions,
String permissionGroup) {
public AdminGrantedPermissionsPreferenceControllerTestBase(String key, String[] permissions) {
mKey = key;
mPermissions = permissions;
mPermissionGroup = permissionGroup;
}
@Before
@@ -69,12 +61,6 @@ 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) {
@@ -96,7 +82,6 @@ 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(
@@ -105,33 +90,27 @@ 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

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

@@ -16,14 +16,16 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import com.android.settings.R;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -33,10 +35,6 @@ import org.mockito.Mock;
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;
/**
* Tests for {@link AlwaysOnVpnCurrentUserPreferenceController}.
*/
@@ -51,7 +49,6 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private AlwaysOnVpnCurrentUserPreferenceController mController;
@@ -60,18 +57,11 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new AlwaysOnVpnCurrentUserPreferenceController(mContext,
null /* lifecycle */);
mController = new AlwaysOnVpnCurrentUserPreferenceController(mContext);
when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_device))
.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
@@ -95,12 +85,10 @@ 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

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

@@ -16,13 +16,15 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -32,10 +34,6 @@ import org.mockito.Mock;
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;
/**
* Tests for {@link AlwaysOnVpnManagedProfilePreferenceController}.
*/
@@ -48,7 +46,6 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private AlwaysOnVpnManagedProfilePreferenceController mController;
@@ -57,14 +54,7 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext,
null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext);
}
@Test
@@ -72,12 +62,10 @@ 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

10
tests/robotests/src/com/android/settings/enterprise/ApplicationListFragmentTest.java
View File

@@ -17,9 +17,7 @@
package com.android.settings.enterprise;
import static com.android.settings.testutils.ApplicationTestUtils.buildInfo;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Answers.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.when;
@@ -30,10 +28,10 @@ import android.support.v7.preference.PreferenceScreen;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.applications.UserAppInfo;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.AbstractPreferenceController;
import org.junit.Before;
@@ -86,7 +84,8 @@ public class ApplicationListFragmentTest {
@Test
public void getPreferenceControllers() {
final List<AbstractPreferenceController> controllers = mFragment.getPreferenceControllers(mContext);
final List<AbstractPreferenceController> controllers = mFragment.getPreferenceControllers(
mContext);
assertThat(controllers).isNotNull();
assertThat(controllers.size()).isEqualTo(1);
int position = 0;
@@ -94,7 +93,8 @@ public class ApplicationListFragmentTest {
ApplicationListPreferenceController.class);
}
@Test public void getCategories() {
@Test
public void getCategories() {
assertThat(new ApplicationListFragment.AdminGrantedPermissionCamera().getMetricsCategory())
.isEqualTo(MetricsEvent.ENTERPRISE_PRIVACY_PERMISSIONS);
assertThat(new ApplicationListFragment.AdminGrantedPermissionLocation().

2
tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java
View File

@@ -73,7 +73,7 @@ public final class CaCertsCurrentUserPreferenceControllerTest extends
@Override
CaCertsPreferenceControllerBase createController() {
return new CaCertsCurrentUserPreferenceController(mContext, null /* lifecycle */);
return new CaCertsCurrentUserPreferenceController(mContext);
}
private void assertUpdateState(boolean isCompMode, String expectedTitle) {

2
tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java
View File

@@ -45,6 +45,6 @@ public final class CaCertsManagedProfilePreferenceControllerTest extends
@Override
CaCertsPreferenceControllerBase createController() {
return new CaCertsManagedProfilePreferenceController(mContext, null /* lifecycle */);
return new CaCertsManagedProfilePreferenceController(mContext);
}
}

2
tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerBaseTest.java
View File

@@ -50,7 +50,7 @@ public class CaCertsPreferenceControllerBaseTest extends CaCertsPreferenceContro
CaCertsPreferenceControllerBase {
public CaCertsPreferenceControllerBaseTestable(Context context) {
super(context, null);
super(context);
}
@Override

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

@@ -17,15 +17,12 @@
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 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;
@@ -43,8 +40,6 @@ public abstract class CaCertsPreferenceControllerTestBase {
protected Context mContext;
protected FakeFeatureFactory mFeatureFactory;
protected CaCertsPreferenceControllerBase mController;
@Mock
private PreferenceAvailabilityObserver mObserver;
@Before
public void setUp() {
@@ -52,12 +47,6 @@ public abstract class CaCertsPreferenceControllerTestBase {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = createController();
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -75,11 +64,9 @@ public abstract class CaCertsPreferenceControllerTestBase {
public void testIsAvailable() {
mockGetNumberOfCaCerts(0);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(getPreferenceKey(), false);
mockGetNumberOfCaCerts(10);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(getPreferenceKey(), true);
}
@Test

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

@@ -16,15 +16,20 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.anyObject;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.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 com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -36,15 +41,6 @@ import org.mockito.invocation.InvocationOnMock;
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;
/**
* Tests for {@link EnterpriseInstalledPackagesPreferenceController}.
*/
@@ -58,7 +54,6 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterpriseInstalledPackagesPreferenceController mController;
@@ -68,13 +63,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
FakeFeatureFactory.setupForTest(mContext);
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);
true /* async */);
}
private void setNumberOfEnterpriseInstalledPackages(int number, boolean async) {
@@ -83,8 +72,9 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
((ApplicationFeatureProvider.NumberOfAppsCallback)
invocation.getArguments()[1]).onNumberOfAppsResult(number);
return null;
}}).when(mFeatureFactory.applicationFeatureProvider)
.calculateNumberOfPolicyInstalledApps(eq(async), anyObject());
}
}).when(mFeatureFactory.applicationFeatureProvider)
.calculateNumberOfPolicyInstalledApps(eq(async), anyObject());
}
@Test
@@ -95,8 +85,6 @@ 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(
@@ -105,39 +93,27 @@ 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
public void testIsAvailableSync() {
final EnterpriseInstalledPackagesPreferenceController controller
= new EnterpriseInstalledPackagesPreferenceController(mContext,
null /* lifecycle */, false /* async */);
controller.setAvailabilityObserver(mObserver);
= new EnterpriseInstalledPackagesPreferenceController(mContext, false /* async */);
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

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

@@ -16,14 +16,16 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -33,10 +35,6 @@ import org.mockito.Mock;
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;
/**
* Tests for {@link EnterprisePrivacyPreferenceController}.
*/
@@ -52,7 +50,6 @@ public final class EnterprisePrivacyPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterprisePrivacyPreferenceController mController;
@@ -61,13 +58,7 @@ public final class EnterprisePrivacyPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
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);
mController = new EnterprisePrivacyPreferenceController(mContext);
}
@Test
@@ -88,17 +79,15 @@ public final class EnterprisePrivacyPreferenceControllerTest {
.thenReturn(MANAGING_ORGANIZATION);
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME);
}
}
@Test
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

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

@@ -17,18 +17,16 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.res.XmlResourceParser;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.widget.PreferenceCategoryController;
import com.android.settingslib.core.AbstractPreferenceController;
import org.junit.Before;
@@ -37,14 +35,10 @@ 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;
/**
* Tests for {@link EnterprisePrivacySettings}.
@@ -53,9 +47,6 @@ import java.util.Set;
@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;
@@ -71,23 +62,11 @@ public final class EnterprisePrivacySettingsTest {
}
@Test
public void testGetMetricsCategory() {
public void verifyConstants() {
assertThat(mSettings.getMetricsCategory())
.isEqualTo(MetricsEvent.ENTERPRISE_PRIVACY_SETTINGS);
}
@Test
public void testGetCategoryKey() {
assertThat(mSettings.getCategoryKey()).isNull();
}
@Test
public void testGetLogTag() {
assertThat(mSettings.getLogTag()).isEqualTo("EnterprisePrivacySettings");
}
@Test
public void testGetPreferenceScreenResId() {
assertThat(mSettings.getCategoryKey()).isNull();
assertThat(mSettings.getPreferenceScreenResId())
.isEqualTo(R.xml.enterprise_privacy_settings);
}
@@ -121,7 +100,7 @@ public final class EnterprisePrivacySettingsTest {
public void getSearchIndexProviderPreferenceControllers() throws Exception {
final List<AbstractPreferenceController> controllers
= EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers(
ShadowApplication.getInstance().getApplicationContext());
ShadowApplication.getInstance().getApplicationContext());
verifyPreferenceControllers(controllers);
}
@@ -155,67 +134,11 @@ public final class EnterprisePrivacySettingsTest {
CaCertsCurrentUserPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
CaCertsManagedProfilePreferenceController.class);
final AbstractPreferenceController exposureChangesCategoryController =
controllers.get(position);
final int exposureChangesCategoryControllerIndex = position;
assertThat(controllers.get(position++)).isInstanceOf(
ExposureChangesCategoryPreferenceController.class);
PreferenceCategoryController.class);
assertThat(controllers.get(position++)).isInstanceOf(
FailedPasswordWipeCurrentUserPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
FailedPasswordWipeManagedProfilePreferenceController.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 AbstractPreferenceController 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);
}
}

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

@@ -17,7 +17,6 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.argThat;
@@ -29,16 +28,14 @@ import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.UserInfo;
import android.os.UserHandle;
import android.os.UserManager;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.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 com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -51,8 +48,6 @@ import org.robolectric.annotation.Config;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.Mockito.verify;
/**
* Tests for {@link EnterpriseSetDefaultAppsPreferenceController}.
*/
@@ -65,9 +60,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
@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;
@@ -76,14 +69,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterpriseSetDefaultAppsPreferenceController(mContext,
null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
mController = new EnterpriseSetDefaultAppsPreferenceController(mContext);
}
private void setEnterpriseSetDefaultApps(Intent[] intents, int number) {
@@ -130,12 +116,10 @@ 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

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

@@ -1,192 +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.enterprise;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.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);
}
}

11
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceControllerTest.java
View File

@@ -16,14 +16,14 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import static org.mockito.Mockito.when;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import static org.mockito.Mockito.when;
/**
* Tests for {@link FailedPasswordWipeCurrentUserPreferenceController}.
*/
@@ -32,8 +32,6 @@ import static org.mockito.Mockito.when;
public final class FailedPasswordWipeCurrentUserPreferenceControllerTest extends
FailedPasswordWipePreferenceControllerTestBase {
private int mMaximumFailedPasswordsBeforeWipe = 0;
public FailedPasswordWipeCurrentUserPreferenceControllerTest() {
super("failed_password_wipe_current_user");
}
@@ -41,8 +39,7 @@ public final class FailedPasswordWipeCurrentUserPreferenceControllerTest extends
@Override
public void setUp() {
super.setUp();
mController = new FailedPasswordWipeCurrentUserPreferenceController(mContext,
null /* lifecycle */);
mController = new FailedPasswordWipeCurrentUserPreferenceController(mContext);
}
@Override

11
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java
View File

@@ -16,14 +16,14 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import static org.mockito.Mockito.when;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import static org.mockito.Mockito.when;
/**
* Tests for {@link FailedPasswordWipeManagedProfilePreferenceController}.
*/
@@ -32,8 +32,6 @@ import static org.mockito.Mockito.when;
public final class FailedPasswordWipeManagedProfilePreferenceControllerTest extends
FailedPasswordWipePreferenceControllerTestBase {
private int mMaximumFailedPasswordsBeforeWipe = 0;
public FailedPasswordWipeManagedProfilePreferenceControllerTest() {
super("failed_password_wipe_managed_profile");
}
@@ -41,8 +39,7 @@ public final class FailedPasswordWipeManagedProfilePreferenceControllerTest exte
@Override
public void setUp() {
super.setUp();
mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext,
null /* lifecycle */);
mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext);
}
@Override

5
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java
View File

@@ -16,8 +16,8 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -50,8 +50,7 @@ public final class FailedPasswordWipePreferenceControllerBaseTest extends
private class FailedPasswordWipePreferenceControllerBaseTestable extends
FailedPasswordWipePreferenceControllerBase {
FailedPasswordWipePreferenceControllerBaseTestable() {
super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext,
null /* lifecycle */);
super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext);
}
@Override

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

@@ -16,12 +16,13 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
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,10 +31,6 @@ import org.mockito.Answers;
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;
/**
* Common base for testing subclasses of {@link FailedPasswordWipePreferenceControllerBase}.
*/
@@ -44,7 +41,6 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
protected Context mContext;
protected FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
protected FailedPasswordWipePreferenceControllerBase mController;
@@ -59,12 +55,6 @@ 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
@@ -81,15 +71,11 @@ 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

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

@@ -16,13 +16,15 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -32,10 +34,6 @@ import org.mockito.Mock;
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;
/**
* Tests for {@link GlobalHttpProxyPreferenceController}.
*/
@@ -48,7 +46,6 @@ public final class GlobalHttpProxyPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private GlobalHttpProxyPreferenceController mController;
@@ -57,13 +54,7 @@ public final class GlobalHttpProxyPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
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);
mController = new GlobalHttpProxyPreferenceController(mContext);
}
@Test
@@ -71,12 +62,10 @@ 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

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

@@ -16,15 +16,16 @@
package com.android.settings.enterprise;
import android.content.Context;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import com.android.settings.R;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -34,10 +35,6 @@ import org.mockito.Mock;
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;
/**
* Tests for {@link ImePreferenceController}.
*/
@@ -52,7 +49,6 @@ public final class ImePreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private ImePreferenceController mController;
@@ -61,15 +57,9 @@ public final class ImePreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new ImePreferenceController(mContext, null /* lifecycle */);
mController = new ImePreferenceController(mContext);
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,7 +67,7 @@ public final class ImePreferenceControllerTest {
final Preference preference = new Preference(mContext, null, 0, 0);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(DEFAULT_IME_LABEL);
.thenReturn(DEFAULT_IME_LABEL);
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo(DEFAULT_IME_TEXT);
}
@@ -85,14 +75,12 @@ public final class ImePreferenceControllerTest {
@Test
public void testIsAvailable() {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(null);
.thenReturn(null);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(DEFAULT_IME_LABEL);
.thenReturn(DEFAULT_IME_LABEL);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, true);
}
@Test