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

Commit 77a40731 authored by Oli Lan's avatar Oli Lan Committed by Bill Lin
Browse files

Wait for available rollbacks in RollbackTest. 

This changes RollbackTest to retry checks for available rollbacks for
a certain period of time, using a new RollbackUtils method
waitForAvailableRollbacks.

Currently many of the tests in RollbackTest are flaky due to race conditions
between checking for available rollbacks and the installer onFinished callback.
This CL should fix all of those issues.

The previous attempt to resolve this by adding NewRollbacks speculatively to
the results of getAvailableRollbacks was not successful. This CL reverts that
change so that getAvailableRollbacks once again only returns rollbacks that are
actually available.

Bug: 136548146
Test: atest RollbackTest run on cuttlefish on acloud repeatedly
Change-Id: I0389ef2413e7642fe2f6ef1a33aef218dd1896ed
Merged-In: I27e2513b34f49af2f41cd627a5d2550541831e11
parent dc4a3610

core/java/android/content/rollback/RollbackManager.java

+1 −4
Original line number Original line Diff line number Diff line
@@ -74,10 +74,7 @@ public final class RollbackManager { 
    }

    }





    /**

    /**

     * Returns a list of all currently available rollbacks. This includes ones for very recently

     * Returns a list of all currently available rollbacks.

     * installed packages (even if onFinished has not yet been called). As a result, packages that

     * very recently failed to install may also be included, but those rollbacks will fail with

     * 'rollback not available'.

     *

     *

     * @throws SecurityException if the caller does not have appropriate permissions.

     * @throws SecurityException if the caller does not have appropriate permissions.

     */

     */

services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java

+0 −9
Original line number Original line Diff line number Diff line
@@ -282,15 +282,6 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { 
                    rollbacks.add(rollback.info);

                    rollbacks.add(rollback.info);

                }

                }

            }

            }



            // Also return new rollbacks for which the PackageRollbackInfo is complete.

            for (NewRollback newRollback : mNewRollbacks) {

                if (newRollback.rollback.info.getPackages().size()

                        == newRollback.packageSessionIds.length

                        && !newRollback.isCancelled) {

                    rollbacks.add(newRollback.rollback.info);

                }

            }

            return new ParceledListSlice<>(rollbacks);

            return new ParceledListSlice<>(rollbacks);

        }

        }

    }

    }

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

+24 −51
Original line number Original line Diff line number Diff line
@@ -19,6 +19,8 @@ package com.android.tests.rollback; 
import static com.android.cts.install.lib.InstallUtils.processUserData;

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.RollbackInfoSubject.assertThat;

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

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

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

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





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

import static com.google.common.truth.Truth.assertThat;
@@ -118,8 +120,7 @@ public class RollbackTest { 
            }

            }





            // The app should not be available for rollback.

            // The app should not be available for rollback.

            assertThat(

            waitForUnavailableRollback(TestApp.A);

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





            // There should be no recently committed rollbacks for this package.

            // There should be no recently committed rollbacks for this package.

            assertThat(getUniqueRollbackInfoForPackage(

            assertThat(getUniqueRollbackInfoForPackage(
@@ -134,9 +135,7 @@ public class RollbackTest { 
            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);

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





            // The app should now be available for rollback.

            // The app should now be available for rollback.

            RollbackInfo available = getUniqueRollbackInfoForPackage(

            RollbackInfo available = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(available).isNotNull();

            assertThat(available).isNotStaged();

            assertThat(available).isNotStaged();

            assertThat(available).packagesContainsExactly(

            assertThat(available).packagesContainsExactly(

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

                    Rollback.from(TestApp.A2).to(TestApp.A1));
@@ -197,14 +196,12 @@ public class RollbackTest { 
            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);

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





            // Both test apps should now be available for rollback.

            // Both test apps should now be available for rollback.

            RollbackInfo rollbackA = getUniqueRollbackInfoForPackage(

            RollbackInfo rollbackA = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollbackA).isNotNull();

            assertThat(rollbackA).isNotNull();

            assertThat(rollbackA).packagesContainsExactly(

            assertThat(rollbackA).packagesContainsExactly(

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

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





            RollbackInfo rollbackB = getUniqueRollbackInfoForPackage(

            RollbackInfo rollbackB = waitForAvailableRollback(TestApp.B);

                    rm.getAvailableRollbacks(), TestApp.B);

            assertThat(rollbackB).isNotNull();

            assertThat(rollbackB).isNotNull();

            assertThat(rollbackB).packagesContainsExactly(

            assertThat(rollbackB).packagesContainsExactly(

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

                    Rollback.from(TestApp.B2).to(TestApp.B1));
@@ -213,14 +210,12 @@ public class RollbackTest { 
            rm.reloadPersistedData();

            rm.reloadPersistedData();





            // The apps should still be available for rollback.

            // The apps should still be available for rollback.

            rollbackA = getUniqueRollbackInfoForPackage(

            rollbackA = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollbackA).isNotNull();

            assertThat(rollbackA).isNotNull();

            assertThat(rollbackA).packagesContainsExactly(

            assertThat(rollbackA).packagesContainsExactly(

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

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





            rollbackB = getUniqueRollbackInfoForPackage(

            rollbackB = waitForAvailableRollback(TestApp.B);

                    rm.getAvailableRollbacks(), TestApp.B);

            assertThat(rollbackB).isNotNull();

            assertThat(rollbackB).isNotNull();

            assertThat(rollbackB).packagesContainsExactly(

            assertThat(rollbackB).packagesContainsExactly(

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

                    Rollback.from(TestApp.B2).to(TestApp.B1));
@@ -255,15 +250,13 @@ public class RollbackTest { 
            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);

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





            // The app should now be available for rollback.

            // The app should now be available for rollback.

            RollbackInfo availableA = getUniqueRollbackInfoForPackage(

            RollbackInfo availableA = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(availableA).isNotNull();

            assertThat(availableA).isNotNull();

            assertThat(availableA).packagesContainsExactly(

            assertThat(availableA).packagesContainsExactly(

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

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

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

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





            RollbackInfo availableB = getUniqueRollbackInfoForPackage(

            RollbackInfo availableB = waitForAvailableRollback(TestApp.B);

                    rm.getAvailableRollbacks(), TestApp.B);

            assertThat(availableB).isNotNull();

            assertThat(availableB).isNotNull();

            assertThat(availableB).packagesContainsExactly(

            assertThat(availableB).packagesContainsExactly(

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

                    Rollback.from(TestApp.A2).to(TestApp.A1),
@@ -276,13 +269,13 @@ public class RollbackTest { 
            rm.reloadPersistedData();

            rm.reloadPersistedData();





            // The apps should still be available for rollback.

            // The apps should still be available for rollback.

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

            availableA = waitForAvailableRollback(TestApp.A);

            assertThat(availableA).isNotNull();

            assertThat(availableA).isNotNull();

            assertThat(availableA).packagesContainsExactly(

            assertThat(availableA).packagesContainsExactly(

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

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

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

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





            availableB = getUniqueRollbackInfoForPackage(rm.getAvailableRollbacks(), TestApp.B);

            availableB = waitForAvailableRollback(TestApp.B);

            assertThat(availableB).isNotNull();

            assertThat(availableB).isNotNull();

            assertThat(availableB).packagesContainsExactly(

            assertThat(availableB).packagesContainsExactly(

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

                    Rollback.from(TestApp.A2).to(TestApp.A1),
@@ -334,8 +327,7 @@ public class RollbackTest { 
            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);

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





            // The app should now be available for rollback.

            // The app should now be available for rollback.

            RollbackInfo available = getUniqueRollbackInfoForPackage(

            RollbackInfo available = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(available).isNotNull();

            assertThat(available).isNotNull();





            // Roll back the app.

            // Roll back the app.
@@ -405,13 +397,11 @@ public class RollbackTest { 




            // Check that the rollback data has not expired

            // Check that the rollback data has not expired

            Thread.sleep(1000);

            Thread.sleep(1000);

            RollbackInfo rollback = getUniqueRollbackInfoForPackage(

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNotNull();

            assertThat(rollback).packagesContainsExactly(

            assertThat(rollback).packagesContainsExactly(

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

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





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

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

            Thread.sleep(expirationTime / 2);

            Thread.sleep(expirationTime / 2);

            rollback = getUniqueRollbackInfoForPackage(

            rollback = getUniqueRollbackInfoForPackage(

                    rm.getAvailableRollbacks(), TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);
@@ -536,9 +526,7 @@ public class RollbackTest { 
            assertThat(InstallUtils.getInstalledVersion(TestApp.A)).isEqualTo(2);

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





            // The app should now be available for rollback.

            // The app should now be available for rollback.

            RollbackInfo rollback = getUniqueRollbackInfoForPackage(

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNotNull();

            assertThat(rollback).packagesContainsExactly(

            assertThat(rollback).packagesContainsExactly(

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

                    Rollback.from(TestApp.A2).to(TestApp.A1));
@@ -570,9 +558,7 @@ public class RollbackTest { 
            Install.single(TestApp.A2).setEnableRollback().commit();

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

            processUserData(TestApp.A);

            processUserData(TestApp.A);





            RollbackManager rm = RollbackUtils.getRollbackManager();

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            RollbackInfo rollback = getUniqueRollbackInfoForPackage(

                    rm.getAvailableRollbacks(), TestApp.A);

            RollbackUtils.rollback(rollback.getRollbackId());

            RollbackUtils.rollback(rollback.getRollbackId());

            processUserData(TestApp.A);

            processUserData(TestApp.A);

        } finally {

        } finally {
@@ -598,10 +584,7 @@ public class RollbackTest { 
            Install.single(TestApp.ASplit2).setEnableRollback().commit();

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

            processUserData(TestApp.A);

            processUserData(TestApp.A);





            RollbackManager rm = RollbackUtils.getRollbackManager();

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

            RollbackInfo rollback = getUniqueRollbackInfoForPackage(

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNotNull();

            RollbackUtils.rollback(rollback.getRollbackId());

            RollbackUtils.rollback(rollback.getRollbackId());

            processUserData(TestApp.A);

            processUserData(TestApp.A);

        } finally {

        } finally {
@@ -644,7 +627,6 @@ public class RollbackTest { 
                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.INSTALL_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.DELETE_PACKAGES,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS);

                    Manifest.permission.TEST_MANAGE_ROLLBACKS);

            RollbackManager rm = RollbackUtils.getRollbackManager();





            // Prep installation of the test apps.

            // Prep installation of the test apps.

            Uninstall.packages(TestApp.A);

            Uninstall.packages(TestApp.A);
@@ -659,15 +641,11 @@ public class RollbackTest { 




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

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

            // RollbackInfo returned for the rollbacks should be correct.

            // RollbackInfo returned for the rollbacks should be correct.

            RollbackInfo rollbackA = getUniqueRollbackInfoForPackage(

            RollbackInfo rollbackA = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollbackA).isNotNull();

            assertThat(rollbackA).packagesContainsExactly(

            assertThat(rollbackA).packagesContainsExactly(

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

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





            RollbackInfo rollbackB = getUniqueRollbackInfoForPackage(

            RollbackInfo rollbackB = waitForAvailableRollback(TestApp.B);

                    rm.getAvailableRollbacks(), TestApp.B);

            assertThat(rollbackB).isNotNull();

            assertThat(rollbackB).packagesContainsExactly(

            assertThat(rollbackB).packagesContainsExactly(

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

                    Rollback.from(TestApp.B2).to(TestApp.B1));
@@ -822,8 +800,7 @@ public class RollbackTest { 
            assertThat(InstallUtils.getInstalledVersion(TestApp.B)).isEqualTo(2);

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





            // TestApp.A should now be available for rollback.

            // TestApp.A should now be available for rollback.

            RollbackInfo rollback = getUniqueRollbackInfoForPackage(

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).isNotNull();

            assertThat(rollback).isNotNull();

            assertThat(rollback).packagesContainsExactly(

            assertThat(rollback).packagesContainsExactly(

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

                    Rollback.from(TestApp.A2).to(TestApp.A1),
@@ -938,7 +915,6 @@ public class RollbackTest { 
                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.TEST_MANAGE_ROLLBACKS,

                    Manifest.permission.FORCE_STOP_PACKAGES,

                    Manifest.permission.FORCE_STOP_PACKAGES,

                    Manifest.permission.RESTART_PACKAGES);

                    Manifest.permission.RESTART_PACKAGES);

            RollbackManager rm = RollbackUtils.getRollbackManager();





            // Prep installation of the test apps.

            // Prep installation of the test apps.

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

            Uninstall.packages(TestApp.A, TestApp.B);
@@ -952,13 +928,11 @@ public class RollbackTest { 




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

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

            // targetPackage returned for rollback should be correct.

            // targetPackage returned for rollback should be correct.

            RollbackInfo rollbackA = getUniqueRollbackInfoForPackage(

            RollbackInfo rollbackA = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollbackA).packagesContainsExactly(

            assertThat(rollbackA).packagesContainsExactly(

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

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





            RollbackInfo rollbackB = getUniqueRollbackInfoForPackage(

            RollbackInfo rollbackB = waitForAvailableRollback(TestApp.B);

                    rm.getAvailableRollbacks(), TestApp.B);

            assertThat(rollbackB).packagesContainsExactly(

            assertThat(rollbackB).packagesContainsExactly(

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

                    Rollback.from(TestApp.B2).to(TestApp.B1));
@@ -1002,8 +976,7 @@ public class RollbackTest { 
            Install.single(TestApp.A2).setEnableRollback().commit();

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

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

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





            RollbackInfo rollback = getUniqueRollbackInfoForPackage(

            RollbackInfo rollback = waitForAvailableRollback(TestApp.A);

                    rm.getAvailableRollbacks(), TestApp.A);

            assertThat(rollback).packagesContainsExactly(

            assertThat(rollback).packagesContainsExactly(

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

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