1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package com.android.settings.development; 17 18 import static org.mockito.Matchers.any; 19 import static org.mockito.Matchers.anyInt; 20 import static org.mockito.Matchers.anyString; 21 import static org.mockito.Mockito.mock; 22 import static org.mockito.Mockito.spy; 23 import static org.mockito.Mockito.verify; 24 import static org.mockito.Mockito.when; 25 26 import android.app.admin.DevicePolicyManager; 27 import android.content.Context; 28 import android.content.Intent; 29 import android.content.pm.PackageManager; 30 import android.content.pm.ResolveInfo; 31 import android.os.UserManager; 32 import android.provider.Settings.Global; 33 import android.support.v7.preference.PreferenceScreen; 34 35 import com.android.settings.SettingsRobolectricTestRunner; 36 import com.android.settings.TestConfig; 37 import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; 38 import com.android.settingslib.RestrictedSwitchPreference; 39 40 import org.junit.Before; 41 import org.junit.Test; 42 import org.junit.runner.RunWith; 43 import org.mockito.Mock; 44 import org.mockito.MockitoAnnotations; 45 import org.robolectric.annotation.Config; 46 import org.robolectric.shadows.ShadowApplication; 47 import org.robolectric.util.ReflectionHelpers; 48 49 import java.util.Collections; 50 import java.util.List; 51 52 @RunWith(SettingsRobolectricTestRunner.class) 53 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) 54 public class VerifyAppsOverUsbPreferenceControllerTest { 55 56 @Mock 57 private PackageManager mPackageManager; 58 @Mock 59 private PreferenceScreen mScreen; 60 @Mock 61 private RestrictedSwitchPreference mPreference; 62 63 @Mock 64 private VerifyAppsOverUsbPreferenceController.RestrictedLockUtilsDelegate 65 mRestrictedLockUtilsDelegate; 66 67 private Context mContext; 68 private VerifyAppsOverUsbPreferenceController mController; 69 70 /** Convenience class for setting global int settings. */ 71 class GlobalSetter { set(String setting, int value)72 public GlobalSetter set(String setting, int value) { 73 Global.putInt(mContext.getContentResolver(), setting, value); 74 return this; 75 } 76 } 77 private final GlobalSetter mGlobals = new GlobalSetter(); 78 79 @Before setUp()80 public void setUp() { 81 MockitoAnnotations.initMocks(this); 82 final ShadowApplication shadowContext = ShadowApplication.getInstance(); 83 mContext = spy(shadowContext.getApplicationContext()); 84 when(mScreen.findPreference(anyString())).thenReturn(mPreference); 85 when(mContext.getPackageManager()).thenReturn(mPackageManager); 86 mController = new VerifyAppsOverUsbPreferenceController(mContext); 87 ReflectionHelpers.setField( 88 mController, "mRestrictedLockUtils", mRestrictedLockUtilsDelegate); 89 } 90 setupVerifyBroadcastReceivers(boolean nonEmpty)91 private void setupVerifyBroadcastReceivers(boolean nonEmpty) { 92 final List<ResolveInfo> resolveInfos = nonEmpty 93 ? Collections.singletonList(mock(ResolveInfo.class)) 94 : Collections.<ResolveInfo>emptyList(); 95 when(mPackageManager.queryBroadcastReceivers((Intent) any(), anyInt())) 96 .thenReturn(resolveInfos); 97 } 98 setupEnforcedAdmin(EnforcedAdmin result)99 private void setupEnforcedAdmin(EnforcedAdmin result) { 100 when(mRestrictedLockUtilsDelegate.checkIfRestrictionEnforced( 101 (Context) any(), anyString(), anyInt())).thenReturn(result); 102 } 103 104 @Test updateState_preferenceCheckedWhenSettingIsOn()105 public void updateState_preferenceCheckedWhenSettingIsOn() { 106 setupVerifyBroadcastReceivers(true); 107 setupEnforcedAdmin(null); 108 mGlobals.set(Global.ADB_ENABLED, 1).set(Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1); 109 mController.displayPreference(mScreen); 110 mController.updatePreference(); 111 verify(mPreference).setChecked(true); 112 } 113 114 @Test updateState_preferenceUncheckedWhenSettingIsOff()115 public void updateState_preferenceUncheckedWhenSettingIsOff() { 116 setupVerifyBroadcastReceivers(true); 117 setupEnforcedAdmin(null); 118 mGlobals.set(Global.ADB_ENABLED, 1).set(Global.PACKAGE_VERIFIER_INCLUDE_ADB, 0); 119 mController.displayPreference(mScreen); 120 mController.updatePreference(); 121 verify(mPreference).setChecked(false); 122 } 123 124 @Test updateState_preferenceUncheckedWhenNoAdb()125 public void updateState_preferenceUncheckedWhenNoAdb() { 126 setupVerifyBroadcastReceivers(true); 127 setupEnforcedAdmin(null); 128 mGlobals.set(Global.ADB_ENABLED, 0).set(Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1); 129 mController.displayPreference(mScreen); 130 mController.updatePreference(); 131 verify(mPreference).setChecked(false); 132 } 133 134 @Test updateState_preferenceUncheckedWhenVerifierIsOff()135 public void updateState_preferenceUncheckedWhenVerifierIsOff() { 136 setupVerifyBroadcastReceivers(true); 137 setupEnforcedAdmin(null); 138 mGlobals.set(Global.ADB_ENABLED, 1) 139 .set(Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1) 140 .set(Global.PACKAGE_VERIFIER_ENABLE, 0); 141 mController.displayPreference(mScreen); 142 mController.updatePreference(); 143 verify(mPreference).setChecked(false); 144 } 145 146 @Test updateState_preferenceUncheckedWhenNoVerifyBroadcastReceivers()147 public void updateState_preferenceUncheckedWhenNoVerifyBroadcastReceivers() { 148 setupVerifyBroadcastReceivers(false); 149 setupEnforcedAdmin(null); 150 mGlobals.set(Global.ADB_ENABLED, 1) 151 .set(Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1); 152 mController.displayPreference(mScreen); 153 mController.updatePreference(); 154 verify(mPreference).setChecked(false); 155 } 156 157 @Test updateState_preferenceDisabledWhenRestrictedByAdmin()158 public void updateState_preferenceDisabledWhenRestrictedByAdmin() { 159 setupVerifyBroadcastReceivers(true); 160 final EnforcedAdmin admin = new EnforcedAdmin(); 161 setupEnforcedAdmin(admin); 162 mGlobals.set(Global.ADB_ENABLED, 1) 163 .set(Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1); 164 mController.displayPreference(mScreen); 165 mController.updatePreference(); 166 verify(mPreference).setDisabledByAdmin(admin); 167 } 168 169 @Test updateState_preferenceRemovedWhenVerifierSettingsVisibleIsOff()170 public void updateState_preferenceRemovedWhenVerifierSettingsVisibleIsOff() { 171 setupVerifyBroadcastReceivers(true); 172 mGlobals.set(Global.PACKAGE_VERIFIER_SETTING_VISIBLE, 0); 173 when(mPreference.getKey()).thenReturn(mController.getPreferenceKey()); 174 when(mScreen.getPreferenceCount()).thenReturn(1); 175 when(mScreen.getPreference(anyInt())).thenReturn(mPreference); 176 mController.displayPreference(mScreen); 177 verify(mScreen).removePreference(mPreference); 178 } 179 }