Merge "Remove tests (13/n)" (af8a2d69) · Commits · e / os / android_frameworks_base

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.