Merge "[AAPM] Tests for ActionDisabledByAdminDialog and ExternalSources page" into main

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());
+    }
 }

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(mAdminComponent, UserHandle.of(
-        final EnforcedAdmin expectedAdmin = new EnforcedAdmin(component, UserHandle.of(userId));
+                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);
+    }
 }