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

Commit d50a536d authored by Pavel Grafov's avatar Pavel Grafov
Browse files

Unit test for screen timeout policy handling in Settings 

This is a follow-up for http://ag/3123412

Test: make ROBOTEST_FILTER=LockAfterTimeoutPreferenceControllerTest RunSettingsRoboTests
Test: make ROBOTEST_FILTER=TimeoutPreferenceControllerTest RunSettingsRoboTests

Bug: 63908311
Change-Id: I27631743d52163f3b6d1589b427ba617e74725a9
parent 92a1a0f2

src/com/android/settings/display/TimeoutPreferenceController.java

+2 −2
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ import android.util.Log; 
import com.android.settings.R;

import com.android.settings.TimeoutListPreference;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settings.wrapper.DevicePolicyManagerWrapper;

import com.android.settingslib.RestrictedLockUtils;

import com.android.settingslib.core.AbstractPreferenceController;
@@ -59,8 +60,7 @@ public class TimeoutPreferenceController extends AbstractPreferenceController im 
        final long currentTimeout = Settings.System.getLong(mContext.getContentResolver(),

                SCREEN_OFF_TIMEOUT, FALLBACK_SCREEN_TIMEOUT_VALUE);

        timeoutListPreference.setValue(String.valueOf(currentTimeout));

        final DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(

                Context.DEVICE_POLICY_SERVICE);

        final DevicePolicyManagerWrapper dpm = DevicePolicyManagerWrapper.from(mContext);

        if (dpm != null) {

            final RestrictedLockUtils.EnforcedAdmin admin =

                    RestrictedLockUtils.checkIfMaximumTimeToLockIsSet(mContext);

src/com/android/settings/security/screenlock/LockAfterTimeoutPreferenceController.java

+3 −2
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ import com.android.settings.TimeoutListPreference; 
import com.android.settings.core.PreferenceControllerMixin;

import com.android.settings.overlay.FeatureFactory;

import com.android.settings.security.trustagent.TrustAgentManager;

import com.android.settings.wrapper.DevicePolicyManagerWrapper;

import com.android.settingslib.RestrictedLockUtils;

import com.android.settingslib.core.AbstractPreferenceController;
@@ -43,14 +44,14 @@ public class LockAfterTimeoutPreferenceController extends AbstractPreferenceCont 
    private final int mUserId;

    private final LockPatternUtils mLockPatternUtils;

    private final TrustAgentManager mTrustAgentManager;

    private final DevicePolicyManager mDPM;

    private final DevicePolicyManagerWrapper mDPM;



    public LockAfterTimeoutPreferenceController(Context context, int userId,

            LockPatternUtils lockPatternUtils) {

        super(context);

        mUserId = userId;

        mLockPatternUtils = lockPatternUtils;

        mDPM = context.getSystemService(DevicePolicyManager.class);

        mDPM = DevicePolicyManagerWrapper.from(context);

        mTrustAgentManager = FeatureFactory.getFactory(context)

                .getSecurityFeatureProvider().getTrustAgentManager();

    }

src/com/android/settings/wrapper/DevicePolicyManagerWrapper.java

+10 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ package com.android.settings.wrapper; 


import android.annotation.NonNull;

import android.annotation.Nullable;

import android.annotation.UserIdInt;

import android.app.admin.DevicePolicyManager;

import android.content.ComponentName;

import android.content.Context;
@@ -216,4 +217,13 @@ public class DevicePolicyManagerWrapper { 
    public int getDeviceOwnerUserId() {

        return mDpm.getDeviceOwnerUserId();

    }



    /**

     * Calls {@code DevicePolicyManager#getMaximumTimeToLock()}.

     *

     * @see DevicePolicyManager#getMaximumTimeToLock(ComponentName, int)

     */

    public long getMaximumTimeToLockForUserAndProfiles(@UserIdInt int userHandle) {

        return mDpm.getMaximumTimeToLockForUserAndProfiles(userHandle);

    }

}

tests/robotests/src/com/android/settings/display/TimeoutPreferenceControllerTest.java

+43 −8
Original line number Diff line number Diff line
@@ -16,38 +16,54 @@ 


package com.android.settings.display;



import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.content.Context;

import android.os.UserHandle;

import android.os.UserManager;

import android.provider.Settings;

import com.android.settings.testutils.SettingsRobolectricTestRunner;



import com.android.settings.TestConfig;

import com.android.settings.TimeoutListPreference;

import com.android.settings.testutils.SettingsRobolectricTestRunner;

import com.android.settings.testutils.shadow.ShadowDevicePolicyManagerWrapper;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Answers;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.annotation.Config;



import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;

import static com.google.common.truth.Truth.assertThat;

import java.util.Collections;



@RunWith(SettingsRobolectricTestRunner.class)

@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)

@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION,

        shadows = {ShadowDevicePolicyManagerWrapper.class})

public class TimeoutPreferenceControllerTest {

    private static final int TIMEOUT = 30;

    @Mock(answer = Answers.RETURNS_DEEP_STUBS)

    private Context mContext;

    @Mock

    private TimeoutListPreference mPreference;

    private TimeoutPreferenceController mController;

    @Mock

    private UserManager mUserManager;



    private TimeoutPreferenceController mController;

    private static final String KEY_SCREEN_TIMEOUT = "screen_timeout";



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);



        mContext = spy(RuntimeEnvironment.application);

        when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);

        mController = new TimeoutPreferenceController(mContext, KEY_SCREEN_TIMEOUT);

    }
@@ -59,4 +75,23 @@ public class TimeoutPreferenceControllerTest { 
                SCREEN_OFF_TIMEOUT, 0);

        assertThat(mode).isEqualTo(TIMEOUT);

    }



    @Test

    public void testUpdateStateNoAdminTimeouts() {

        when(mUserManager.getProfiles(anyInt())).thenReturn(Collections.emptyList());

        mController.updateState(mPreference);

        verify(mPreference).removeUnusableTimeouts(0, null);

    }



    @Test

    public void testUpdateStateWithAdminTimeouts() {

        final int profileUserId = UserHandle.myUserId();

        final long timeout = 10000;

        when(mUserManager.getProfiles(profileUserId)).thenReturn(Collections.emptyList());

        ShadowDevicePolicyManagerWrapper

                .setMaximumTimeToLockForUserAndProfiles(profileUserId, timeout);



        mController.updateState(mPreference);

        verify(mPreference).removeUnusableTimeouts(timeout, null);

    }

}

tests/robotests/src/com/android/settings/security/screenlock/LockAfterTimeoutPreferenceControllerTest.java

+40 −5
Original line number Diff line number Diff line
@@ -16,18 +16,29 @@ 


package com.android.settings.security.screenlock;



import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.app.admin.DevicePolicyManager;

import android.content.Context;

import android.support.v14.preference.SwitchPreference;

import android.os.UserHandle;

import android.os.UserManager;

import android.provider.Settings;

import android.support.v7.preference.Preference;



import com.android.internal.widget.LockPatternUtils;

import com.android.settings.TestConfig;

import com.android.settings.TimeoutListPreference;

import com.android.settings.security.trustagent.TrustAgentManager;

import com.android.settings.testutils.FakeFeatureFactory;

import com.android.settings.testutils.SettingsRobolectricTestRunner;

import com.android.settings.testutils.shadow.ShadowDevicePolicyManagerWrapper;



import org.junit.Before;

import org.junit.Test;
@@ -37,8 +48,11 @@ import org.mockito.MockitoAnnotations; 
import org.robolectric.RuntimeEnvironment;

import org.robolectric.annotation.Config;



import java.util.Collections;



@RunWith(SettingsRobolectricTestRunner.class)

@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)

@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION,

        shadows = {ShadowDevicePolicyManagerWrapper.class})

public class LockAfterTimeoutPreferenceControllerTest {



    private static final int TEST_USER_ID = 0;
@@ -47,21 +61,21 @@ public class LockAfterTimeoutPreferenceControllerTest { 
    private LockPatternUtils mLockPatternUtils;

    @Mock

    private TrustAgentManager mTrustAgentManager;

    @Mock

    private TimeoutListPreference mPreference;



    private Context mContext;

    private LockAfterTimeoutPreferenceController mController;

    private SwitchPreference mPreference;

    private FakeFeatureFactory mFeatureFactory;



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = RuntimeEnvironment.application;

        mContext = spy(RuntimeEnvironment.application);

        mFeatureFactory = FakeFeatureFactory.setupForTest();

        when(mFeatureFactory.securityFeatureProvider.getTrustAgentManager())

                .thenReturn(mTrustAgentManager);



        mPreference = new SwitchPreference(mContext);

        mController = new LockAfterTimeoutPreferenceController(

                mContext, TEST_USER_ID, mLockPatternUtils);

    }
@@ -100,5 +114,26 @@ public class LockAfterTimeoutPreferenceControllerTest { 
        assertThat(mController.isAvailable()).isFalse();

    }



    @Test

    public void testUpdateStateWithAdminTimeouts() {

        final int userId = UserHandle.myUserId();

        final long adminTimeout = 10000;

        final int displayTimeout = 5000;



        final UserManager um = mock(UserManager.class);

        when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(um);

        when(um.getProfiles(userId)).thenReturn(Collections.emptyList());



        // Fake list of timeout values.

        when(mPreference.getEntries()).thenReturn(new CharSequence[] {"10"} );

        when(mPreference.getEntryValues()).thenReturn(new CharSequence[] {"10000"} );



        Settings.System.putInt(mContext.getContentResolver(), SCREEN_OFF_TIMEOUT, displayTimeout);

        ShadowDevicePolicyManagerWrapper

                .setMaximumTimeToLockForUserAndProfiles(userId, adminTimeout);



        mController.updateState((Preference) mPreference);



        verify(mPreference).removeUnusableTimeouts(adminTimeout - displayTimeout, null);

    }

}