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 }