Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a6ec9026 authored by Azhara Assanova's avatar Azhara Assanova
Browse files

[AAPM] Tests for ActionDisabledByAdminDialog and ExternalSources page

Bug: 358229113
Bug: 369361373
Test: atest ActionDisabledByAdminDialogTest
Test: atest ExternalSourcesDetailsTest
Flag: TEST_ONLY
Change-Id: I11f0f32be4fceeccb092eca49f37227c80bef033
parent 7313080e
Loading
Loading
Loading
Loading
+145 −0
Original line number Diff line number Diff line
@@ -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());
    }
}
+87 −4
Original line number Diff line number Diff line
@@ -16,38 +16,72 @@

package com.android.settings.enterprise;

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