| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.server.timezone; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import android.app.timezone.Callback; |
| import android.app.timezone.DistroRulesVersion; |
| import android.app.timezone.ICallback; |
| import android.app.timezone.RulesManager; |
| import android.app.timezone.RulesState; |
| import android.os.ParcelFileDescriptor; |
| |
| import java.io.IOException; |
| import java.util.concurrent.Executor; |
| import javax.annotation.Nullable; |
| import libcore.tzdata.shared2.DistroVersion; |
| import libcore.tzdata.shared2.StagedDistroOperation; |
| import libcore.tzdata.update2.TimeZoneDistroInstaller; |
| |
| import static com.android.server.timezone.RulesManagerService.REQUIRED_UPDATER_PERMISSION; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| import static org.mockito.Matchers.eq; |
| import static org.mockito.Mockito.doNothing; |
| import static org.mockito.Mockito.doReturn; |
| import static org.mockito.Mockito.doThrow; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.reset; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.verifyNoMoreInteractions; |
| import static org.mockito.Mockito.when; |
| |
| /** |
| * White box interaction / unit testing of the {@link RulesManagerService}. |
| */ |
| public class RulesManagerServiceTest { |
| |
| private RulesManagerService mRulesManagerService; |
| |
| private FakeExecutor mFakeExecutor; |
| private PermissionHelper mMockPermissionHelper; |
| private FileDescriptorHelper mMockFileDescriptorHelper; |
| private PackageTracker mMockPackageTracker; |
| private TimeZoneDistroInstaller mMockTimeZoneDistroInstaller; |
| |
| @Before |
| public void setUp() { |
| mFakeExecutor = new FakeExecutor(); |
| |
| mMockFileDescriptorHelper = mock(FileDescriptorHelper.class); |
| mMockPackageTracker = mock(PackageTracker.class); |
| mMockPermissionHelper = mock(PermissionHelper.class); |
| mMockTimeZoneDistroInstaller = mock(TimeZoneDistroInstaller.class); |
| |
| mRulesManagerService = new RulesManagerService( |
| mMockPermissionHelper, |
| mFakeExecutor, |
| mMockFileDescriptorHelper, |
| mMockPackageTracker, |
| mMockTimeZoneDistroInstaller); |
| } |
| |
| @Test(expected = SecurityException.class) |
| public void getRulesState_noCallerPermission() throws Exception { |
| configureCallerDoesNotHavePermission(); |
| mRulesManagerService.getRulesState(); |
| } |
| |
| @Test(expected = SecurityException.class) |
| public void requestInstall_noCallerPermission() throws Exception { |
| configureCallerDoesNotHavePermission(); |
| mRulesManagerService.requestInstall(null, null, null); |
| } |
| |
| @Test(expected = SecurityException.class) |
| public void requestUninstall_noCallerPermission() throws Exception { |
| configureCallerDoesNotHavePermission(); |
| mRulesManagerService.requestUninstall(null, null); |
| } |
| |
| @Test(expected = SecurityException.class) |
| public void requestNothing_noCallerPermission() throws Exception { |
| configureCallerDoesNotHavePermission(); |
| mRulesManagerService.requestNothing(null, true); |
| } |
| |
| @Test |
| public void getRulesState_systemRulesError() throws Exception { |
| configureDeviceCannotReadSystemRulesVersion(); |
| |
| assertNull(mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_stagedInstall() throws Exception { |
| configureCallerHasPermission(); |
| |
| configureDeviceSystemRulesVersion("2016a"); |
| |
| DistroVersion stagedDistroVersion = new DistroVersion( |
| DistroVersion.CURRENT_FORMAT_MAJOR_VERSION, |
| DistroVersion.CURRENT_FORMAT_MINOR_VERSION - 1, |
| "2016c", |
| 3); |
| configureStagedInstall(stagedDistroVersion); |
| |
| DistroVersion installedDistroVersion = new DistroVersion( |
| DistroVersion.CURRENT_FORMAT_MAJOR_VERSION, |
| DistroVersion.CURRENT_FORMAT_MINOR_VERSION - 1, |
| "2016b", |
| 4); |
| configureInstalledDistroVersion(installedDistroVersion); |
| |
| DistroRulesVersion stagedDistroRulesVersion = new DistroRulesVersion( |
| stagedDistroVersion.rulesVersion, stagedDistroVersion.revision); |
| DistroRulesVersion installedDistroRulesVersion = new DistroRulesVersion( |
| installedDistroVersion.rulesVersion, installedDistroVersion.revision); |
| RulesState expectedRuleState = new RulesState( |
| "2016a", RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| false /* operationInProgress */, |
| RulesState.STAGED_OPERATION_INSTALL, stagedDistroRulesVersion, |
| RulesState.DISTRO_STATUS_INSTALLED, installedDistroRulesVersion); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_nothingStaged() throws Exception { |
| configureCallerHasPermission(); |
| |
| configureDeviceSystemRulesVersion("2016a"); |
| |
| configureNoStagedOperation(); |
| |
| DistroVersion installedDistroVersion = new DistroVersion( |
| DistroVersion.CURRENT_FORMAT_MAJOR_VERSION, |
| DistroVersion.CURRENT_FORMAT_MINOR_VERSION - 1, |
| "2016b", |
| 4); |
| configureInstalledDistroVersion(installedDistroVersion); |
| |
| DistroRulesVersion installedDistroRulesVersion = new DistroRulesVersion( |
| installedDistroVersion.rulesVersion, installedDistroVersion.revision); |
| RulesState expectedRuleState = new RulesState( |
| "2016a", RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| false /* operationInProgress */, |
| RulesState.STAGED_OPERATION_NONE, null /* stagedDistroRulesVersion */, |
| RulesState.DISTRO_STATUS_INSTALLED, installedDistroRulesVersion); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_uninstallStaged() throws Exception { |
| configureCallerHasPermission(); |
| |
| configureDeviceSystemRulesVersion("2016a"); |
| |
| configureStagedUninstall(); |
| |
| DistroVersion installedDistroVersion = new DistroVersion( |
| DistroVersion.CURRENT_FORMAT_MAJOR_VERSION, |
| DistroVersion.CURRENT_FORMAT_MINOR_VERSION - 1, |
| "2016b", |
| 4); |
| configureInstalledDistroVersion(installedDistroVersion); |
| |
| DistroRulesVersion installedDistroRulesVersion = new DistroRulesVersion( |
| installedDistroVersion.rulesVersion, installedDistroVersion.revision); |
| RulesState expectedRuleState = new RulesState( |
| "2016a", RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| false /* operationInProgress */, |
| RulesState.STAGED_OPERATION_UNINSTALL, null /* stagedDistroRulesVersion */, |
| RulesState.DISTRO_STATUS_INSTALLED, installedDistroRulesVersion); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_installedRulesError() throws Exception { |
| configureCallerHasPermission(); |
| |
| String systemRulesVersion = "2016a"; |
| configureDeviceSystemRulesVersion(systemRulesVersion); |
| |
| configureStagedUninstall(); |
| configureDeviceCannotReadInstalledDistroVersion(); |
| |
| RulesState expectedRuleState = new RulesState( |
| "2016a", RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| false /* operationInProgress */, |
| RulesState.STAGED_OPERATION_UNINSTALL, null /* stagedDistroRulesVersion */, |
| RulesState.DISTRO_STATUS_UNKNOWN, null /* installedDistroRulesVersion */); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_stagedRulesError() throws Exception { |
| configureCallerHasPermission(); |
| |
| String systemRulesVersion = "2016a"; |
| configureDeviceSystemRulesVersion(systemRulesVersion); |
| |
| configureDeviceCannotReadStagedDistroOperation(); |
| |
| DistroVersion installedDistroVersion = new DistroVersion( |
| DistroVersion.CURRENT_FORMAT_MAJOR_VERSION, |
| DistroVersion.CURRENT_FORMAT_MINOR_VERSION - 1, |
| "2016b", |
| 4); |
| configureInstalledDistroVersion(installedDistroVersion); |
| |
| DistroRulesVersion installedDistroRulesVersion = new DistroRulesVersion( |
| installedDistroVersion.rulesVersion, installedDistroVersion.revision); |
| RulesState expectedRuleState = new RulesState( |
| "2016a", RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| false /* operationInProgress */, |
| RulesState.STAGED_OPERATION_UNKNOWN, null /* stagedDistroRulesVersion */, |
| RulesState.DISTRO_STATUS_INSTALLED, installedDistroRulesVersion); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_noInstalledRules() throws Exception { |
| configureCallerHasPermission(); |
| |
| String systemRulesVersion = "2016a"; |
| configureDeviceSystemRulesVersion(systemRulesVersion); |
| configureNoStagedOperation(); |
| configureInstalledDistroVersion(null); |
| |
| RulesState expectedRuleState = new RulesState( |
| systemRulesVersion, RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| false /* operationInProgress */, |
| RulesState.STAGED_OPERATION_NONE, null /* stagedDistroRulesVersion */, |
| RulesState.DISTRO_STATUS_NONE, null /* installedDistroRulesVersion */); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void getRulesState_operationInProgress() throws Exception { |
| configureCallerHasPermission(); |
| |
| String systemRulesVersion = "2016a"; |
| String installedRulesVersion = "2016b"; |
| int revision = 3; |
| |
| configureDeviceSystemRulesVersion(systemRulesVersion); |
| |
| DistroVersion installedDistroVersion = new DistroVersion( |
| DistroVersion.CURRENT_FORMAT_MAJOR_VERSION, |
| DistroVersion.CURRENT_FORMAT_MINOR_VERSION - 1, |
| installedRulesVersion, |
| revision); |
| configureInstalledDistroVersion(installedDistroVersion); |
| |
| byte[] expectedContent = createArbitraryBytes(1000); |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| configureParcelFileDescriptorReadSuccess(parcelFileDescriptor, expectedContent); |
| |
| // Start an async operation so there is one in progress. The mFakeExecutor won't actually |
| // execute it. |
| byte[] tokenBytes = createArbitraryTokenBytes(); |
| ICallback callback = new StubbedCallback(); |
| |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback); |
| |
| RulesState expectedRuleState = new RulesState( |
| systemRulesVersion, RulesManagerService.DISTRO_FORMAT_VERSION_SUPPORTED, |
| true /* operationInProgress */, |
| RulesState.STAGED_OPERATION_UNKNOWN, null /* stagedDistroRulesVersion */, |
| RulesState.DISTRO_STATUS_UNKNOWN, null /* installedDistroRulesVersion */); |
| assertEquals(expectedRuleState, mRulesManagerService.getRulesState()); |
| } |
| |
| @Test |
| public void requestInstall_operationInProgress() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] expectedContent = createArbitraryBytes(1000); |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| configureParcelFileDescriptorReadSuccess(parcelFileDescriptor, expectedContent); |
| |
| byte[] tokenBytes = createArbitraryTokenBytes(); |
| ICallback callback = new StubbedCallback(); |
| |
| // First request should succeed. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback)); |
| |
| // Something async should be enqueued. Clear it but do not execute it so we can detect the |
| // second request does nothing. |
| mFakeExecutor.getAndResetLastCommand(); |
| |
| // Second request should fail. |
| assertEquals(RulesManager.ERROR_OPERATION_IN_PROGRESS, |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback)); |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestInstall_badToken() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] expectedContent = createArbitraryBytes(1000); |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| configureParcelFileDescriptorReadSuccess(parcelFileDescriptor, expectedContent); |
| |
| byte[] badTokenBytes = new byte[2]; |
| ICallback callback = new StubbedCallback(); |
| |
| try { |
| mRulesManagerService.requestInstall(parcelFileDescriptor, badTokenBytes, callback); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestInstall_nullParcelFileDescriptor() throws Exception { |
| configureCallerHasPermission(); |
| |
| ParcelFileDescriptor parcelFileDescriptor = null; |
| byte[] tokenBytes = createArbitraryTokenBytes(); |
| ICallback callback = new StubbedCallback(); |
| |
| try { |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback); |
| fail(); |
| } catch (NullPointerException expected) {} |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestInstall_nullCallback() throws Exception { |
| configureCallerHasPermission(); |
| |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| byte[] tokenBytes = createArbitraryTokenBytes(); |
| ICallback callback = null; |
| |
| try { |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback); |
| fail(); |
| } catch (NullPointerException expected) {} |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestInstall_asyncSuccess() throws Exception { |
| configureCallerHasPermission(); |
| |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| byte[] expectedContent = createArbitraryBytes(1000); |
| configureParcelFileDescriptorReadSuccess(parcelFileDescriptor, expectedContent); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the install. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback)); |
| |
| // Assert nothing has happened yet. |
| callback.assertNoResultReceived(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| |
| // Set up the installer. |
| configureStageInstallExpectation(expectedContent, TimeZoneDistroInstaller.INSTALL_SUCCESS); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify the expected calls were made to other components. |
| verifyStageInstallCalled(expectedContent); |
| verifyPackageTrackerCalled(token, true /* success */); |
| |
| // Check the callback was called. |
| callback.assertResultReceived(Callback.SUCCESS); |
| } |
| |
| @Test |
| public void requestInstall_nullTokenBytes() throws Exception { |
| configureCallerHasPermission(); |
| |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| byte[] expectedContent = createArbitraryBytes(1000); |
| configureParcelFileDescriptorReadSuccess(parcelFileDescriptor, expectedContent); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the install. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestInstall( |
| parcelFileDescriptor, null /* tokenBytes */, callback)); |
| |
| // Assert nothing has happened yet. |
| verifyNoInstallerCallsMade(); |
| callback.assertNoResultReceived(); |
| |
| // Set up the installer. |
| configureStageInstallExpectation(expectedContent, TimeZoneDistroInstaller.INSTALL_SUCCESS); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify the expected calls were made to other components. |
| verifyStageInstallCalled(expectedContent); |
| verifyPackageTrackerCalled(null /* expectedToken */, true /* success */); |
| |
| // Check the callback was received. |
| callback.assertResultReceived(Callback.SUCCESS); |
| } |
| |
| @Test |
| public void requestInstall_asyncInstallFail() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] expectedContent = createArbitraryBytes(1000); |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| configureParcelFileDescriptorReadSuccess(parcelFileDescriptor, expectedContent); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the install. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback)); |
| |
| // Assert nothing has happened yet. |
| verifyNoInstallerCallsMade(); |
| callback.assertNoResultReceived(); |
| |
| // Set up the installer. |
| configureStageInstallExpectation( |
| expectedContent, TimeZoneDistroInstaller.INSTALL_FAIL_VALIDATION_ERROR); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify the expected calls were made to other components. |
| verifyStageInstallCalled(expectedContent); |
| |
| // Validation failure is treated like a successful check: repeating it won't improve things. |
| boolean expectedSuccess = true; |
| verifyPackageTrackerCalled(token, expectedSuccess); |
| |
| // Check the callback was received. |
| callback.assertResultReceived(Callback.ERROR_INSTALL_VALIDATION_ERROR); |
| } |
| |
| @Test |
| public void requestInstall_asyncParcelFileDescriptorReadFail() throws Exception { |
| configureCallerHasPermission(); |
| |
| ParcelFileDescriptor parcelFileDescriptor = createFakeParcelFileDescriptor(); |
| configureParcelFileDescriptorReadFailure(parcelFileDescriptor); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the install. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestInstall(parcelFileDescriptor, tokenBytes, callback)); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify nothing else happened. |
| verifyNoInstallerCallsMade(); |
| |
| // A failure to read the ParcelFileDescriptor is treated as a failure. It might be the |
| // result of a file system error. This is a fairly arbitrary choice. |
| verifyPackageTrackerCalled(token, false /* success */); |
| |
| verifyNoPackageTrackerCallsMade(); |
| |
| // Check the callback was received. |
| callback.assertResultReceived(Callback.ERROR_UNKNOWN_FAILURE); |
| } |
| |
| @Test |
| public void requestUninstall_operationInProgress() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] tokenBytes = createArbitraryTokenBytes(); |
| ICallback callback = new StubbedCallback(); |
| |
| // First request should succeed. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestUninstall(tokenBytes, callback)); |
| |
| // Something async should be enqueued. Clear it but do not execute it so we can detect the |
| // second request does nothing. |
| mFakeExecutor.getAndResetLastCommand(); |
| |
| // Second request should fail. |
| assertEquals(RulesManager.ERROR_OPERATION_IN_PROGRESS, |
| mRulesManagerService.requestUninstall(tokenBytes, callback)); |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestUninstall_badToken() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] badTokenBytes = new byte[2]; |
| ICallback callback = new StubbedCallback(); |
| |
| try { |
| mRulesManagerService.requestUninstall(badTokenBytes, callback); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestUninstall_nullCallback() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] tokenBytes = createArbitraryTokenBytes(); |
| ICallback callback = null; |
| |
| try { |
| mRulesManagerService.requestUninstall(tokenBytes, callback); |
| fail(); |
| } catch (NullPointerException expected) {} |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestUninstall_asyncSuccess() throws Exception { |
| configureCallerHasPermission(); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the uninstall. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestUninstall(tokenBytes, callback)); |
| |
| // Assert nothing has happened yet. |
| callback.assertNoResultReceived(); |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| |
| // Set up the installer. |
| configureStageUninstallExpectation(true /* success */); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify the expected calls were made to other components. |
| verifyStageUninstallCalled(); |
| verifyPackageTrackerCalled(token, true /* success */); |
| |
| // Check the callback was called. |
| callback.assertResultReceived(Callback.SUCCESS); |
| } |
| |
| @Test |
| public void requestUninstall_nullTokenBytes() throws Exception { |
| configureCallerHasPermission(); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the uninstall. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestUninstall(null /* tokenBytes */, callback)); |
| |
| // Assert nothing has happened yet. |
| verifyNoInstallerCallsMade(); |
| callback.assertNoResultReceived(); |
| |
| // Set up the installer. |
| configureStageUninstallExpectation(true /* success */); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify the expected calls were made to other components. |
| verifyStageUninstallCalled(); |
| verifyPackageTrackerCalled(null /* expectedToken */, true /* success */); |
| |
| // Check the callback was received. |
| callback.assertResultReceived(Callback.SUCCESS); |
| } |
| |
| @Test |
| public void requestUninstall_asyncUninstallFail() throws Exception { |
| configureCallerHasPermission(); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| TestCallback callback = new TestCallback(); |
| |
| // Request the uninstall. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestUninstall(tokenBytes, callback)); |
| |
| // Assert nothing has happened yet. |
| verifyNoInstallerCallsMade(); |
| callback.assertNoResultReceived(); |
| |
| // Set up the installer. |
| configureStageUninstallExpectation(false /* success */); |
| |
| // Simulate the async execution. |
| mFakeExecutor.simulateAsyncExecutionOfLastCommand(); |
| |
| // Verify the expected calls were made to other components. |
| verifyStageUninstallCalled(); |
| verifyPackageTrackerCalled(token, false /* success */); |
| |
| // Check the callback was received. |
| callback.assertResultReceived(Callback.ERROR_UNKNOWN_FAILURE); |
| } |
| |
| @Test |
| public void requestNothing_operationInProgressOk() throws Exception { |
| configureCallerHasPermission(); |
| |
| // Set up a parallel operation. |
| assertEquals(RulesManager.SUCCESS, |
| mRulesManagerService.requestUninstall(null, new StubbedCallback())); |
| // Something async should be enqueued. Clear it but do not execute it to simulate it still |
| // being in progress. |
| mFakeExecutor.getAndResetLastCommand(); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| // Make the call. |
| mRulesManagerService.requestNothing(tokenBytes, true /* success */); |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| |
| // Verify the expected calls were made to other components. |
| verifyPackageTrackerCalled(token, true /* success */); |
| verifyNoInstallerCallsMade(); |
| } |
| |
| @Test |
| public void requestNothing_badToken() throws Exception { |
| configureCallerHasPermission(); |
| |
| byte[] badTokenBytes = new byte[2]; |
| |
| try { |
| mRulesManagerService.requestNothing(badTokenBytes, true /* success */); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Assert nothing async was enqueued. |
| mFakeExecutor.assertNothingQueued(); |
| |
| // Assert no other calls were made. |
| verifyNoInstallerCallsMade(); |
| verifyNoPackageTrackerCallsMade(); |
| } |
| |
| @Test |
| public void requestNothing() throws Exception { |
| configureCallerHasPermission(); |
| |
| CheckToken token = createArbitraryToken(); |
| byte[] tokenBytes = token.toByteArray(); |
| |
| // Make the call. |
| mRulesManagerService.requestNothing(tokenBytes, false /* success */); |
| |
| // Assert everything required was done. |
| verifyNoInstallerCallsMade(); |
| verifyPackageTrackerCalled(token, false /* success */); |
| } |
| |
| @Test |
| public void requestNothing_nullTokenBytes() throws Exception { |
| configureCallerHasPermission(); |
| |
| // Make the call. |
| mRulesManagerService.requestNothing(null /* tokenBytes */, true /* success */); |
| |
| // Assert everything required was done. |
| verifyNoInstallerCallsMade(); |
| verifyPackageTrackerCalled(null /* token */, true /* success */); |
| } |
| |
| private void verifyNoPackageTrackerCallsMade() { |
| verifyNoMoreInteractions(mMockPackageTracker); |
| reset(mMockPackageTracker); |
| } |
| |
| private void verifyPackageTrackerCalled( |
| CheckToken expectedCheckToken, boolean expectedSuccess) { |
| verify(mMockPackageTracker).recordCheckResult(expectedCheckToken, expectedSuccess); |
| reset(mMockPackageTracker); |
| } |
| |
| private void configureCallerHasPermission() throws Exception { |
| doNothing() |
| .when(mMockPermissionHelper) |
| .enforceCallerHasPermission(REQUIRED_UPDATER_PERMISSION); |
| } |
| |
| private void configureCallerDoesNotHavePermission() { |
| doThrow(new SecurityException("Simulated permission failure")) |
| .when(mMockPermissionHelper) |
| .enforceCallerHasPermission(REQUIRED_UPDATER_PERMISSION); |
| } |
| |
| private void configureParcelFileDescriptorReadSuccess(ParcelFileDescriptor parcelFileDescriptor, |
| byte[] content) throws Exception { |
| when(mMockFileDescriptorHelper.readFully(parcelFileDescriptor)).thenReturn(content); |
| } |
| |
| private void configureParcelFileDescriptorReadFailure(ParcelFileDescriptor parcelFileDescriptor) |
| throws Exception { |
| when(mMockFileDescriptorHelper.readFully(parcelFileDescriptor)) |
| .thenThrow(new IOException("Simulated failure")); |
| } |
| |
| private void configureStageInstallExpectation(byte[] expectedContent, int resultCode) |
| throws Exception { |
| when(mMockTimeZoneDistroInstaller.stageInstallWithErrorCode(eq(expectedContent))) |
| .thenReturn(resultCode); |
| } |
| |
| private void configureStageUninstallExpectation(boolean success) throws Exception { |
| doReturn(success).when(mMockTimeZoneDistroInstaller).stageUninstall(); |
| } |
| |
| private void verifyStageInstallCalled(byte[] expectedContent) throws Exception { |
| verify(mMockTimeZoneDistroInstaller).stageInstallWithErrorCode(eq(expectedContent)); |
| verifyNoMoreInteractions(mMockTimeZoneDistroInstaller); |
| reset(mMockTimeZoneDistroInstaller); |
| } |
| |
| private void verifyStageUninstallCalled() throws Exception { |
| verify(mMockTimeZoneDistroInstaller).stageUninstall(); |
| verifyNoMoreInteractions(mMockTimeZoneDistroInstaller); |
| reset(mMockTimeZoneDistroInstaller); |
| } |
| |
| private void verifyNoInstallerCallsMade() { |
| verifyNoMoreInteractions(mMockTimeZoneDistroInstaller); |
| reset(mMockTimeZoneDistroInstaller); |
| } |
| |
| private static byte[] createArbitraryBytes(int length) { |
| byte[] bytes = new byte[length]; |
| for (int i = 0; i < length; i++) { |
| bytes[i] = (byte) i; |
| } |
| return bytes; |
| } |
| |
| private byte[] createArbitraryTokenBytes() { |
| return createArbitraryToken().toByteArray(); |
| } |
| |
| private CheckToken createArbitraryToken() { |
| return new CheckToken(1, new PackageVersions(1, 1)); |
| } |
| |
| private ParcelFileDescriptor createFakeParcelFileDescriptor() { |
| return new ParcelFileDescriptor((ParcelFileDescriptor) null); |
| } |
| |
| private void configureDeviceSystemRulesVersion(String systemRulesVersion) throws Exception { |
| when(mMockTimeZoneDistroInstaller.getSystemRulesVersion()).thenReturn(systemRulesVersion); |
| } |
| |
| private void configureInstalledDistroVersion(@Nullable DistroVersion installedDistroVersion) |
| throws Exception { |
| when(mMockTimeZoneDistroInstaller.getInstalledDistroVersion()) |
| .thenReturn(installedDistroVersion); |
| } |
| |
| private void configureStagedInstall(DistroVersion stagedDistroVersion) throws Exception { |
| when(mMockTimeZoneDistroInstaller.getStagedDistroOperation()) |
| .thenReturn(StagedDistroOperation.install(stagedDistroVersion)); |
| } |
| |
| private void configureStagedUninstall() throws Exception { |
| when(mMockTimeZoneDistroInstaller.getStagedDistroOperation()) |
| .thenReturn(StagedDistroOperation.uninstall()); |
| } |
| |
| private void configureNoStagedOperation() throws Exception { |
| when(mMockTimeZoneDistroInstaller.getStagedDistroOperation()).thenReturn(null); |
| } |
| |
| private void configureDeviceCannotReadStagedDistroOperation() throws Exception { |
| when(mMockTimeZoneDistroInstaller.getStagedDistroOperation()) |
| .thenThrow(new IOException("Simulated failure")); |
| } |
| |
| private void configureDeviceCannotReadSystemRulesVersion() throws Exception { |
| when(mMockTimeZoneDistroInstaller.getSystemRulesVersion()) |
| .thenThrow(new IOException("Simulated failure")); |
| } |
| |
| private void configureDeviceCannotReadInstalledDistroVersion() throws Exception { |
| when(mMockTimeZoneDistroInstaller.getInstalledDistroVersion()) |
| .thenThrow(new IOException("Simulated failure")); |
| } |
| |
| private static class FakeExecutor implements Executor { |
| |
| private Runnable mLastCommand; |
| |
| @Override |
| public void execute(Runnable command) { |
| assertNull(mLastCommand); |
| assertNotNull(command); |
| mLastCommand = command; |
| } |
| |
| public Runnable getAndResetLastCommand() { |
| assertNotNull(mLastCommand); |
| Runnable toReturn = mLastCommand; |
| mLastCommand = null; |
| return toReturn; |
| } |
| |
| public void simulateAsyncExecutionOfLastCommand() { |
| Runnable toRun = getAndResetLastCommand(); |
| toRun.run(); |
| } |
| |
| public void assertNothingQueued() { |
| assertNull(mLastCommand); |
| } |
| } |
| |
| private static class TestCallback extends ICallback.Stub { |
| |
| private boolean mOnFinishedCalled; |
| private int mLastError; |
| |
| @Override |
| public void onFinished(int error) { |
| assertFalse(mOnFinishedCalled); |
| mOnFinishedCalled = true; |
| mLastError = error; |
| } |
| |
| public void assertResultReceived(int expectedResult) { |
| assertTrue(mOnFinishedCalled); |
| assertEquals(expectedResult, mLastError); |
| } |
| |
| public void assertNoResultReceived() { |
| assertFalse(mOnFinishedCalled); |
| } |
| } |
| |
| private static class StubbedCallback extends ICallback.Stub { |
| @Override |
| public void onFinished(int error) { |
| fail("Unexpected call"); |
| } |
| } |
| } |