diff --git a/tests/robotests/src/com/android/settings/applications/appinfo/ExternalSourcesDetailsTest.java b/tests/robotests/src/com/android/settings/applications/appinfo/ExternalSourcesDetailsTest.java index 10c2675be82..65c9caf4302 100644 --- a/tests/robotests/src/com/android/settings/applications/appinfo/ExternalSourcesDetailsTest.java +++ b/tests/robotests/src/com/android/settings/applications/appinfo/ExternalSourcesDetailsTest.java @@ -16,28 +16,48 @@ package com.android.settings.applications.appinfo; +import static android.os.UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES; +import static android.os.UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY; +import static android.os.UserManager.RESTRICTION_SOURCE_DEVICE_OWNER; +import static android.os.UserManager.RESTRICTION_SOURCE_PROFILE_OWNER; +import static android.os.UserManager.RESTRICTION_SOURCE_SYSTEM; +import static android.security.advancedprotection.AdvancedProtectionManager.ADVANCED_PROTECTION_SYSTEM_ENTITY; + import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.nullable; import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; +import android.app.admin.EnforcingAdmin; +import android.app.admin.UnknownAuthority; +import android.content.ComponentName; import android.content.Context; import android.content.ContextWrapper; import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.os.UserHandle; import android.os.UserManager; +import android.platform.test.annotations.RequiresFlagsDisabled; +import android.platform.test.annotations.RequiresFlagsEnabled; +import android.platform.test.flag.junit.CheckFlagsRule; +import android.platform.test.flag.junit.DeviceFlagsValueProvider; +import android.security.Flags; import com.android.settings.applications.AppStateInstallAppsBridge; import com.android.settings.applications.AppStateInstallAppsBridge.InstallAppsState; import com.android.settings.testutils.shadow.ShadowUserManager; import com.android.settingslib.RestrictedPreferenceHelper; import com.android.settingslib.RestrictedSwitchPreference; +import com.android.settingslib.applications.ApplicationsState.AppEntry; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -51,15 +71,27 @@ import org.robolectric.util.ReflectionHelpers; @RunWith(RobolectricTestRunner.class) @Config(shadows = {ShadowUserManager.class}) public class ExternalSourcesDetailsTest { + @Rule + public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); + @Mock + private Context mContext; @Mock private UserManager mUserManager; @Mock + private DevicePolicyManager mDevicePolicyManager; + @Mock private RestrictedSwitchPreference mSwitchPref; @Mock private RestrictedPreferenceHelper mHelper; @Mock private PackageInfo mPackageInfo; + @Mock + private AppEntry mAppEntry; + + private final int mAppUid = 10123; + private final String mPackageName = "test.pkg"; + private final UserHandle mUserHandle = UserHandle.getUserHandleForUid(mAppUid); private ExternalSourcesDetails mFragment; @@ -67,9 +99,17 @@ public class ExternalSourcesDetailsTest { public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mDevicePolicyManager).when(mContext).getSystemService(DevicePolicyManager.class); + doReturn(mUserManager).when(mContext).getSystemService(Context.USER_SERVICE); + mFragment = new ExternalSourcesDetails(); ReflectionHelpers.setField(mFragment, "mUserManager", mUserManager); ReflectionHelpers.setField(mFragment, "mSwitchPref", mSwitchPref); + + ApplicationInfo applicationInfo = new ApplicationInfo(); + applicationInfo.uid = mAppUid; + applicationInfo.packageName = mPackageName; + mAppEntry.info = applicationInfo; } @Test @@ -226,4 +266,109 @@ public class ExternalSourcesDetailsTest { UserHandle.of(UserHandle.myUserId()))).isTrue(); assertThat(mSwitchPref.isDisabledByAdmin()).isTrue(); } + + @RequiresFlagsDisabled(android.security.Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_restrictedBySystem_adminString() { + when(mUserManager.getUserRestrictionSource(DISALLOW_INSTALL_UNKNOWN_SOURCES, mUserHandle)) + .thenReturn(RESTRICTION_SOURCE_SYSTEM); + when(mContext + .getString(com.android.settingslib.widget.restricted.R.string.disabled_by_admin)) + .thenReturn("disabled_by_admin"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled_by_admin", summary.toString()); + } + + @RequiresFlagsDisabled(android.security.Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_restrictedByProfileOwner_disabledString() { + when(mUserManager.getUserRestrictionSource(DISALLOW_INSTALL_UNKNOWN_SOURCES, mUserHandle)) + .thenReturn(RESTRICTION_SOURCE_PROFILE_OWNER); + when(mContext.getString(com.android.settingslib.R.string.disabled)).thenReturn("disabled"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled", summary.toString()); + } + + @RequiresFlagsDisabled(android.security.Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_restrictedByDeviceOwner_disabledString() { + when(mUserManager.getUserRestrictionSource(DISALLOW_INSTALL_UNKNOWN_SOURCES, mUserHandle)) + .thenReturn(RESTRICTION_SOURCE_DEVICE_OWNER); + when(mContext.getString(com.android.settingslib.R.string.disabled)).thenReturn("disabled"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled", summary.toString()); + } + + @RequiresFlagsEnabled(android.security.Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_baseRestricted_disabledString() { + when(mUserManager.hasBaseUserRestriction(DISALLOW_INSTALL_UNKNOWN_SOURCES, mUserHandle)) + .thenReturn(true); + when(mContext.getString(com.android.settingslib.R.string.disabled)).thenReturn("disabled"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled", summary.toString()); + } + + @RequiresFlagsEnabled(android.security.Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_restrictedOnUser_adminString() { + when(mUserManager.hasUserRestrictionForUser(DISALLOW_INSTALL_UNKNOWN_SOURCES, mUserHandle)) + .thenReturn(true); + when(mContext + .getString(com.android.settingslib.widget.restricted.R.string.disabled_by_admin)) + .thenReturn("disabled_by_admin"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled_by_admin", summary.toString()); + } + + @RequiresFlagsEnabled(android.security.Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_restrictedGlobally_adminString() { + final EnforcingAdmin nonAdvancedProtectionEnforcingAdmin = new EnforcingAdmin("test.pkg", + UnknownAuthority.UNKNOWN_AUTHORITY, mUserHandle, new ComponentName("", "")); + + when(mDevicePolicyManager.getEnforcingAdmin(mUserHandle.getIdentifier(), + DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY)).thenReturn( + nonAdvancedProtectionEnforcingAdmin); + when(mUserManager.hasUserRestrictionForUser(DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY, + mUserHandle)).thenReturn(true); + when(mContext + .getString(com.android.settingslib.widget.restricted.R.string.disabled_by_admin)) + .thenReturn("disabled_by_admin"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled_by_admin", summary.toString()); + } + + @RequiresFlagsEnabled(Flags.FLAG_AAPM_FEATURE_DISABLE_INSTALL_UNKNOWN_SOURCES) + @Test + public void getPreferenceSummary_restrictedGlobally_advancedProtectionString() { + final EnforcingAdmin advancedProtectionEnforcingAdmin = new EnforcingAdmin("test.pkg", + new UnknownAuthority(ADVANCED_PROTECTION_SYSTEM_ENTITY), mUserHandle, + new ComponentName("", "")); + + when(mDevicePolicyManager.getEnforcingAdmin(mUserHandle.getIdentifier(), + DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY)).thenReturn( + advancedProtectionEnforcingAdmin); + when(mUserManager.hasUserRestrictionForUser(DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY, + mUserHandle)).thenReturn(true); + when(mContext.getString( + com.android.settingslib.widget.restricted.R.string.disabled_by_advanced_protection)) + .thenReturn("disabled_by_advanced_protection"); + + CharSequence summary = ExternalSourcesDetails.getPreferenceSummary(mContext, mAppEntry); + + assertEquals("disabled_by_advanced_protection", summary.toString()); + } } diff --git a/tests/robotests/src/com/android/settings/enterprise/ActionDisabledByAdminDialogTest.java b/tests/robotests/src/com/android/settings/enterprise/ActionDisabledByAdminDialogTest.java index 75bd672b955..4b7abec906a 100644 --- a/tests/robotests/src/com/android/settings/enterprise/ActionDisabledByAdminDialogTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/ActionDisabledByAdminDialogTest.java @@ -16,38 +16,72 @@ package com.android.settings.enterprise; -import static org.junit.Assert.assertEquals; +import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK; +import static android.security.advancedprotection.AdvancedProtectionManager.ACTION_SHOW_ADVANCED_PROTECTION_SUPPORT_DIALOG; +import static android.security.advancedprotection.AdvancedProtectionManager.ADVANCED_PROTECTION_SYSTEM_ENTITY; +import static android.security.advancedprotection.AdvancedProtectionManager.EXTRA_SUPPORT_DIALOG_FEATURE; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.app.admin.Authority; import android.app.admin.DevicePolicyManager; +import android.app.admin.EnforcingAdmin; +import android.app.admin.UnknownAuthority; import android.content.ComponentName; import android.content.Intent; import android.os.UserHandle; +import android.os.UserManager; +import android.platform.test.annotations.RequiresFlagsEnabled; +import android.platform.test.flag.junit.CheckFlagsRule; +import android.platform.test.flag.junit.DeviceFlagsValueProvider; +import android.security.advancedprotection.AdvancedProtectionManager; import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; @RunWith(RobolectricTestRunner.class) public class ActionDisabledByAdminDialogTest { + @Rule + public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); + + @Mock + private DevicePolicyManager mDevicePolicyManager; + @Mock + private AdvancedProtectionManager mAdvancedProtectionManager; private ActionDisabledByAdminDialog mDialog; + private final ComponentName mAdminComponent = new ComponentName("admin", "adminclass"); @Before public void setUp() { - mDialog = new ActionDisabledByAdminDialog(); + MockitoAnnotations.initMocks(this); + mDialog = spy(new ActionDisabledByAdminDialog()); + doReturn(mDevicePolicyManager).when(mDialog).getSystemService(DevicePolicyManager.class); + doReturn(mAdvancedProtectionManager).when(mDialog).getSystemService( + AdvancedProtectionManager.class); } @Test public void testGetAdminDetailsFromIntent() { final int userId = 123; - final ComponentName component = new ComponentName("com.some.package", ".SomeClass"); - final EnforcedAdmin expectedAdmin = new EnforcedAdmin(component, UserHandle.of(userId)); + final EnforcedAdmin expectedAdmin = new EnforcedAdmin(mAdminComponent, UserHandle.of( + userId)); final Intent intent = new Intent(); - intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, component); + intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, mAdminComponent); intent.putExtra(Intent.EXTRA_USER_ID, userId); assertEquals(expectedAdmin, mDialog.getAdminDetailsFromIntent(intent)); } @@ -73,4 +107,53 @@ public class ActionDisabledByAdminDialogTest { public void testGetRestrictionFromNullIntent() { assertEquals(null, mDialog.getRestrictionFromIntent(null)); } + + @RequiresFlagsEnabled(android.security.Flags.FLAG_AAPM_API) + @Test + public void testGetAdminDetailsFromIntent_nullComponent_advancedProtection_launchesNewDialog() { + final int userId = UserHandle.myUserId(); + final Authority advancedProtectionAuthority = new UnknownAuthority( + ADVANCED_PROTECTION_SYSTEM_ENTITY); + final EnforcingAdmin advancedProtectionEnforcingAdmin = new EnforcingAdmin("test.pkg", + advancedProtectionAuthority, UserHandle.of(userId), mAdminComponent); + final String userRestriction = UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY; + + final Intent apmIntent = new Intent(ACTION_SHOW_ADVANCED_PROTECTION_SUPPORT_DIALOG); + apmIntent.setFlags(FLAG_ACTIVITY_NEW_TASK); + apmIntent.putExtra(EXTRA_SUPPORT_DIALOG_FEATURE, "featureId"); + + final Intent dialogIntent = new Intent(); + dialogIntent.putExtra(Intent.EXTRA_USER_ID, userId); + dialogIntent.putExtra(DevicePolicyManager.EXTRA_RESTRICTION, userRestriction); + + when(mDevicePolicyManager.getEnforcingAdmin(userId, userRestriction)) + .thenReturn(advancedProtectionEnforcingAdmin); + when(mAdvancedProtectionManager.createSupportIntentForPolicyIdentifierOrRestriction( + userRestriction, /* type */ null)).thenReturn(apmIntent); + doNothing().when(mDialog).startActivityAsUser(apmIntent, UserHandle.of(userId)); + + mDialog.getAdminDetailsFromIntent(dialogIntent); + + verify(mDialog).startActivityAsUser(apmIntent, UserHandle.of(userId)); + assertTrue(mDialog.isFinishing()); + } + + @RequiresFlagsEnabled(android.security.Flags.FLAG_AAPM_API) + @Test + public void testGetAdminDetailsFromIntent_nullComponent_notAdvancedProtection_retrievesAdmin() { + final int userId = UserHandle.myUserId(); + final EnforcingAdmin nonAdvancedProtectionEnforcingAdmin = new EnforcingAdmin("test.pkg", + UnknownAuthority.UNKNOWN_AUTHORITY, UserHandle.of(userId), mAdminComponent); + final String userRestriction = UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY; + + final Intent dialogIntent = new Intent(); + dialogIntent.putExtra(Intent.EXTRA_USER_ID, userId); + dialogIntent.putExtra(DevicePolicyManager.EXTRA_RESTRICTION, userRestriction); + + when(mDevicePolicyManager.getEnforcingAdmin(userId, userRestriction)) + .thenReturn(nonAdvancedProtectionEnforcingAdmin); + + EnforcedAdmin admin = mDialog.getAdminDetailsFromIntent(dialogIntent); + assertEquals(mAdminComponent, admin.component); + } }