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

Commit be3c348c authored by JW Wang's avatar JW Wang
Browse files

Remove tests (13/n) 

Remove tests that have been migrated to CTS-root/CTS.

* RollbackTest#testMultipleRollbackAvailable is removed.
  The test is no longer needed as the API it tests
  (RollbackManager#getAvailableRollback(String packageName))
  is removed by ag/6153954.

Bug: 194971428
Test: m StagedRollbackTest RollbackTest
Change-Id: I044f24427c94e2037defe203655c1f8ec25fa6c6
parent efdf2388

tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/RollbackTest.java

+0 −443
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 


package com.android.tests.rollback;



import static com.android.cts.install.lib.InstallUtils.processUserData;

import static com.android.cts.rollback.lib.RollbackInfoSubject.assertThat;

import static com.android.cts.rollback.lib.RollbackUtils.getUniqueRollbackInfoForPackage;

import static com.android.cts.rollback.lib.RollbackUtils.waitForAvailableRollback;
@@ -34,7 +33,6 @@ import android.content.IntentFilter; 
import android.content.rollback.RollbackInfo;

import android.content.rollback.RollbackManager;

import android.os.UserManager;

import android.provider.DeviceConfig;

import android.util.Log;



import androidx.test.InstrumentationRegistry;
@@ -69,12 +67,6 @@ public class RollbackTest { 


    private static final String INSTRUMENTED_APP = "com.android.tests.rollback";



    // copied from PackageManagerService#PROPERTY_ENABLE_ROLLBACK_TIMEOUT_MILLIS

    // TODO: find a better place for the property so that it can be imported in tests

    // maybe android.content.pm.PackageManager?

    private static final String PROPERTY_ENABLE_ROLLBACK_TIMEOUT_MILLIS =

            "enable_rollback_timeout";



    private static boolean hasRollbackInclude(List<RollbackInfo> rollbacks, String packageName) {

        return rollbacks.stream().anyMatch(

                ri -> ri.getPackages().stream().anyMatch(
@@ -201,355 +193,6 @@ public class RollbackTest { 
        }

    }



    /**

     * Test the scheduling aspect of rollback expiration.

     */

    @Test

    public void testRollbackExpiresAfterLifetime() throws Exception {

        long expirationTime = TimeUnit.SECONDS.toMillis(30);

        long defaultExpirationTime = TimeUnit.HOURS.toMillis(48);

        RollbackManager rm = RollbackUtils.getRollbackManager();



        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.WRITE_DEVICE_CONFIG);



            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

                    RollbackManager.PROPERTY_ROLLBACK_LIFETIME_MILLIS,

                    Long.toString(expirationTime), false /* makeDefault*/);



            // Uninstall TestApp.A

            Uninstall.packages(TestApp.A);

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(-1);



            // Install v1 of the app (without rollbacks enabled).

            Install.single(TestApp.A1).commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(1);



            // Upgrade from v1 to v2, with rollbacks enabled.

            Install.single(TestApp.A2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);



            // Check that the rollback data has not expired

            Thread.sleep(1000);

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            assertThat(rollback).packagesContainsExactly(

                    Rollback.from(TestApp.A2).to(TestApp.A1));



            // Give it a little more time, but still not long enough to expire

            Thread.sleep(expirationTime / 2);

            rollback = getUniqueRollbackInfoForPackage(

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNotNull();

            assertThat(rollback).packagesContainsExactly(

                    Rollback.from(TestApp.A2).to(TestApp.A1));



            // Check that the data has expired after the expiration time (with a buffer of 1 second)

            Thread.sleep(expirationTime / 2);

            rollback = getUniqueRollbackInfoForPackage(

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNull();



        } finally {

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

                    RollbackManager.PROPERTY_ROLLBACK_LIFETIME_MILLIS,

                    Long.toString(defaultExpirationTime), false /* makeDefault*/);

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    /**

     * Test that available rollbacks should expire correctly when the property

     * {@link RollbackManager#PROPERTY_ROLLBACK_LIFETIME_MILLIS} is changed

     */

    @Test

    public void testRollbackExpiresWhenLifetimeChanges() throws Exception {

        long defaultExpirationTime = TimeUnit.HOURS.toMillis(48);

        RollbackManager rm = RollbackUtils.getRollbackManager();



        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.WRITE_DEVICE_CONFIG);



            Uninstall.packages(TestApp.A);

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(-1);

            Install.single(TestApp.A1).commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(1);

            Install.single(TestApp.A2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            assertThat(rollback).packagesContainsExactly(Rollback.from(TestApp.A2).to(TestApp.A1));



            // Change the lifetime to 0 which should expire rollbacks immediately

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

                    RollbackManager.PROPERTY_ROLLBACK_LIFETIME_MILLIS,

                    Long.toString(0), false /* makeDefault*/);



            // Keep polling until device config changes has happened (which might take more than

            // 5 sec depending how busy system_server is) and rollbacks have expired

            for (int i = 0; i < 30; ++i) {

                if (hasRollbackInclude(rm.getAvailableRollbacks(), TestApp.A)) {

                    Thread.sleep(1000);

                }

            }

            rollback = getUniqueRollbackInfoForPackage(rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNull();

        } finally {

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

                    RollbackManager.PROPERTY_ROLLBACK_LIFETIME_MILLIS,

                    Long.toString(defaultExpirationTime), false /* makeDefault*/);

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    /**

     * Test that changing time on device does not affect the duration of time that we keep

     * rollback available

     */

    @Test

    public void testTimeChangeDoesNotAffectLifetime() throws Exception {

        long expirationTime = TimeUnit.SECONDS.toMillis(30);

        long defaultExpirationTime = TimeUnit.HOURS.toMillis(48);

        RollbackManager rm = RollbackUtils.getRollbackManager();



        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.WRITE_DEVICE_CONFIG,

                    Manifest.permission.SET_TIME);



            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

                    RollbackManager.PROPERTY_ROLLBACK_LIFETIME_MILLIS,

                    Long.toString(expirationTime), false /* makeDefault*/);



            // Install app A with rollback enabled

            Uninstall.packages(TestApp.A);

            Install.single(TestApp.A1).commit();

            Install.single(TestApp.A2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);



            Thread.sleep(expirationTime / 2);



            // Install app B with rollback enabled

            Uninstall.packages(TestApp.B);

            Install.single(TestApp.B1).commit();

            Install.single(TestApp.B2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);



            // 1 second buffer

            Thread.sleep(1000);



            try {

                // Change the time

                RollbackUtils.forwardTimeBy(expirationTime);



                // 1 second buffer to allow Rollback Manager to handle time change before loading

                // persisted data

                Thread.sleep(1000);



                // Load timestamps from storage

                rm.reloadPersistedData();



                // Wait until rollback for app A has expired

                // This will trigger an expiration run that should expire app A but not B

                Thread.sleep(expirationTime / 2);

                RollbackInfo rollbackA =

                        getUniqueRollbackInfoForPackage(rm.getAvailableRollbacks(), TestApp.A);

                Log.i(TAG, "Checking if the rollback for TestApp.A is null");



                // Rollback for app B should not be expired

                RollbackInfo rollbackB1 = getUniqueRollbackInfoForPackage(

                        rm.getAvailableRollbacks(), TestApp.B);



                // Wait until rollback for app B has expired

                Thread.sleep(expirationTime / 2);

                RollbackInfo rollbackB2 = getUniqueRollbackInfoForPackage(

                        rm.getAvailableRollbacks(), TestApp.B);



                assertThat(rollbackA).isNull();

                assertThat(rollbackB1).isNotNull();

                assertThat(rollbackB1).packagesContainsExactly(

                        Rollback.from(TestApp.B2).to(TestApp.B1));

                assertThat(rollbackB2).isNull();

            } finally {

                RollbackUtils.forwardTimeBy(-expirationTime);

            }

        } finally {

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

                    RollbackManager.PROPERTY_ROLLBACK_LIFETIME_MILLIS,

                    Long.toString(defaultExpirationTime), false /* makeDefault*/);

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    /**

     * Test explicit expiration of rollbacks.

     * Does not test the scheduling aspects of rollback expiration.

     */

    @Test

    public void testRollbackExpiration() throws Exception {

        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS);



            RollbackManager rm = RollbackUtils.getRollbackManager();

            Uninstall.packages(TestApp.A);

            Install.single(TestApp.A1).commit();

            Install.single(TestApp.A2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);



            // The app should now be available for rollback.

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            assertThat(rollback).packagesContainsExactly(

                    Rollback.from(TestApp.A2).to(TestApp.A1));



            // Expire the rollback.

            rm.expireRollbackForPackage(TestApp.A);



            // The rollback should no longer be available.

            assertThat(getUniqueRollbackInfoForPackage(

                        rm.getAvailableRollbacks(), TestApp.A)).isNull();

        } finally {

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    /**

     * Test that app user data is rolled back.

     */

    @Test

    public void testUserDataRollback() throws Exception {

        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS);



            Uninstall.packages(TestApp.A);

            Install.single(TestApp.A1).commit();

            processUserData(TestApp.A);

            Install.single(TestApp.A2).setEnableRollback().commit();

            processUserData(TestApp.A);



            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            RollbackUtils.rollback(rollback.getRollbackId());

            processUserData(TestApp.A);

        } finally {

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    /**

     * Test rollback of apks involving splits.

     */

    @Test

    public void testRollbackWithSplits() throws Exception {

        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS);



            Uninstall.packages(TestApp.A);

            Install.single(TestApp.ASplit1).commit();

            processUserData(TestApp.A);



            Install.single(TestApp.ASplit2).setEnableRollback().commit();

            processUserData(TestApp.A);



            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            RollbackUtils.rollback(rollback.getRollbackId());

            processUserData(TestApp.A);

        } finally {

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    /**

     * Test restrictions on rollback broadcast sender.

     * A random app should not be able to send a ROLLBACK_COMMITTED broadcast.

     */

    @Test

    public void testRollbackBroadcastRestrictions() throws Exception {

        RollbackBroadcastReceiver broadcastReceiver = new RollbackBroadcastReceiver();

        Intent broadcast = new Intent(Intent.ACTION_ROLLBACK_COMMITTED);

        try {

            InstrumentationRegistry.getContext().sendBroadcast(broadcast);

            fail("Succeeded in sending restricted broadcast from app context.");

        } catch (SecurityException se) {

            // Expected behavior.

        }



        // Confirm that we really haven't received the broadcast.

        // TODO: How long to wait for the expected timeout?

        assertThat(broadcastReceiver.poll(5, TimeUnit.SECONDS)).isNull();



        // TODO: Do we need to do this? Do we need to ensure this is always

        // called, even when the test fails?

        broadcastReceiver.unregister();

    }



    /**

     * Regression test for rollback in the case when multiple apps are

     * available for rollback at the same time.

     */

    @Test

    public void testMultipleRollbackAvailable() throws Exception {

        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS);



            // Prep installation of the test apps.

            Uninstall.packages(TestApp.A);

            Install.single(TestApp.A1).commit();

            Install.single(TestApp.A2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);



            Uninstall.packages(TestApp.B);

            Install.single(TestApp.B1).commit();

            Install.single(TestApp.B2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);



            // Both test apps should now be available for rollback, and the

            // RollbackInfo returned for the rollbacks should be correct.

            RollbackInfo rollbackA = waitForAvailableRollback(TestApp.A);

            assertThat(rollbackA).packagesContainsExactly(

                    Rollback.from(TestApp.A2).to(TestApp.A1));



            RollbackInfo rollbackB = waitForAvailableRollback(TestApp.B);

            assertThat(rollbackB).packagesContainsExactly(

                    Rollback.from(TestApp.B2).to(TestApp.B1));



            // Executing rollback should roll back the correct package.

            RollbackUtils.rollback(rollbackA.getRollbackId());

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(1);

            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);



            Uninstall.packages(TestApp.A);

            Install.single(TestApp.A1).commit();

            Install.single(TestApp.A2).setEnableRollback().commit();

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);



            RollbackUtils.rollback(rollbackB.getRollbackId());

            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);

            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(1);

        } finally {

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    @Test

    @Ignore("b/120200473")

    /**
@@ -687,90 +330,4 @@ public class RollbackTest { 
            InstallUtils.dropShellPermissionIdentity();

        }

    }



    @Test

    public void testEnableRollbackTimeoutFailsRollback() throws Exception {

        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.MANAGE_ROLLBACKS,

                    Manifest.permission.WRITE_DEVICE_CONFIG);



            //setting the timeout to a very short amount that will definitely be triggered

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK,

                    PROPERTY_ENABLE_ROLLBACK_TIMEOUT_MILLIS,

                    Long.toString(0), false /* makeDefault*/);

            RollbackManager rm = RollbackUtils.getRollbackManager();



            Uninstall.packages(TestApp.A);

            Install.single(TestApp.A1).commit();

            waitForUnavailableRollback(TestApp.A);



            // Block the RollbackManager to make extra sure it will not be

            // able to enable the rollback in time.

            rm.blockRollbackManager(TimeUnit.SECONDS.toMillis(1));

            Install.single(TestApp.A2).setEnableRollback().commit();



            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);



            // Give plenty of time for RollbackManager to unblock and attempt

            // to make the rollback available before asserting that the

            // rollback was not made available.

            Thread.sleep(TimeUnit.SECONDS.toMillis(2));

            assertThat(

                getUniqueRollbackInfoForPackage(rm.getAvailableRollbacks(), TestApp.A)).isNull();

        } finally {

            //setting the timeout back to default

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK,

                    PROPERTY_ENABLE_ROLLBACK_TIMEOUT_MILLIS,

                    null, false /* makeDefault*/);

            InstallUtils.dropShellPermissionIdentity();

        }

    }



    @Test

    public void testEnableRollbackTimeoutFailsRollback_MultiPackage() throws Exception {

        try {

            InstallUtils.adoptShellPermissionIdentity(

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.MANAGE_ROLLBACKS,

                    Manifest.permission.WRITE_DEVICE_CONFIG);



            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK,

                    PROPERTY_ENABLE_ROLLBACK_TIMEOUT_MILLIS,

                    Long.toString(5000), false /* makeDefault*/);

            RollbackManager rm = RollbackUtils.getRollbackManager();



            Uninstall.packages(TestApp.A, TestApp.B);

            Install.multi(TestApp.A1, TestApp.B1).commit();

            waitForUnavailableRollback(TestApp.A);



            // Block the 2nd session for 10s so it will not be able to enable the rollback in time.

            rm.blockRollbackManager(TimeUnit.SECONDS.toMillis(0));

            rm.blockRollbackManager(TimeUnit.SECONDS.toMillis(10));

            Install.multi(TestApp.A2, TestApp.B2).setEnableRollback().commit();



            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);

            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);



            // Give plenty of time for RollbackManager to unblock and attempt

            // to make the rollback available before asserting that the

            // rollback was not made available.

            Thread.sleep(TimeUnit.SECONDS.toMillis(2));



            List<RollbackInfo> available = rm.getAvailableRollbacks();

            assertThat(getUniqueRollbackInfoForPackage(available, TestApp.A)).isNull();

            assertThat(getUniqueRollbackInfoForPackage(available, TestApp.B)).isNull();

        } finally {

            //setting the timeout back to default

            DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ROLLBACK,

                    PROPERTY_ENABLE_ROLLBACK_TIMEOUT_MILLIS,

                    null, false /* makeDefault*/);

            InstallUtils.dropShellPermissionIdentity();

        }

    }

}

tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/StagedRollbackTest.java

+0 −269

File changed.

Preview size limit exceeded, changes collapsed.

tests/RollbackTest/StagedRollbackTest/src/com/android/tests/rollback/host/StagedRollbackTest.java

+0 −477

File changed.

Preview size limit exceeded, changes collapsed.