1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17 package com.android.server.backup.restore; 18 19 import static com.android.server.backup.testing.BackupManagerServiceTestUtils.createBackupWakeLock; 20 import static com.android.server.backup.testing.BackupManagerServiceTestUtils.setUpBackupManagerServiceBasics; 21 import static com.android.server.backup.testing.BackupManagerServiceTestUtils.startBackupThreadAndGetLooper; 22 import static com.android.server.backup.testing.TransportData.backupTransport; 23 24 import static com.google.common.truth.Truth.assertThat; 25 26 import static org.mockito.AdditionalMatchers.aryEq; 27 import static org.mockito.ArgumentMatchers.any; 28 import static org.mockito.ArgumentMatchers.anyBoolean; 29 import static org.mockito.ArgumentMatchers.eq; 30 import static org.mockito.ArgumentMatchers.isNull; 31 import static org.mockito.Mockito.doCallRealMethod; 32 import static org.mockito.Mockito.verify; 33 import static org.mockito.Mockito.when; 34 import static org.robolectric.Shadows.shadowOf; 35 import static org.testng.Assert.expectThrows; 36 37 import android.app.Application; 38 import android.app.backup.IBackupManagerMonitor; 39 import android.app.backup.IRestoreObserver; 40 import android.app.backup.IRestoreSession; 41 import android.app.backup.RestoreSet; 42 import android.content.pm.ApplicationInfo; 43 import android.content.pm.PackageInfo; 44 import android.os.Handler; 45 import android.os.Looper; 46 import android.os.PowerManager; 47 import android.os.RemoteException; 48 import android.platform.test.annotations.Presubmit; 49 50 import com.android.server.EventLogTags; 51 import com.android.server.backup.BackupAgentTimeoutParameters; 52 import com.android.server.backup.BackupManagerService; 53 import com.android.server.backup.TransportManager; 54 import com.android.server.backup.internal.BackupHandler; 55 import com.android.server.backup.testing.TransportData; 56 import com.android.server.backup.testing.TransportTestUtils; 57 import com.android.server.backup.testing.TransportTestUtils.TransportMock; 58 import com.android.server.testing.FrameworkRobolectricTestRunner; 59 import com.android.server.testing.SystemLoaderPackages; 60 import com.android.server.testing.shadows.ShadowEventLog; 61 import com.android.server.testing.shadows.ShadowPerformUnifiedRestoreTask; 62 63 import org.junit.After; 64 import org.junit.Before; 65 import org.junit.Test; 66 import org.junit.runner.RunWith; 67 import org.mockito.Mock; 68 import org.mockito.MockitoAnnotations; 69 import org.robolectric.RuntimeEnvironment; 70 import org.robolectric.annotation.Config; 71 import org.robolectric.shadows.ShadowApplication; 72 import org.robolectric.shadows.ShadowBinder; 73 import org.robolectric.shadows.ShadowLooper; 74 import org.robolectric.shadows.ShadowPackageManager; 75 76 import java.util.ArrayDeque; 77 78 @RunWith(FrameworkRobolectricTestRunner.class) 79 @Config( 80 manifest = Config.NONE, 81 sdk = 26, 82 shadows = {ShadowEventLog.class, ShadowPerformUnifiedRestoreTask.class, ShadowBinder.class} 83 ) 84 @SystemLoaderPackages({"com.android.server.backup"}) 85 @Presubmit 86 public class ActiveRestoreSessionTest { 87 private static final String PACKAGE_1 = "com.example.package1"; 88 private static final String PACKAGE_2 = "com.example.package2"; 89 public static final long TOKEN_1 = 1L; 90 public static final long TOKEN_2 = 2L; 91 92 @Mock private BackupManagerService mBackupManagerService; 93 @Mock private TransportManager mTransportManager; 94 @Mock private IRestoreObserver mObserver; 95 @Mock private IBackupManagerMonitor mMonitor; 96 private ShadowLooper mShadowBackupLooper; 97 private ShadowApplication mShadowApplication; 98 private PowerManager.WakeLock mWakeLock; 99 private TransportData mTransport; 100 private RestoreSet mRestoreSet1; 101 private RestoreSet mRestoreSet2; 102 private ShadowPackageManager mShadowPackageManager; 103 104 @Before 105 public void setUp() throws Exception { 106 MockitoAnnotations.initMocks(this); 107 108 mTransport = backupTransport(); 109 110 mRestoreSet1 = new RestoreSet("name1", "device1", TOKEN_1); 111 mRestoreSet2 = new RestoreSet("name2", "device2", TOKEN_2); 112 113 Application application = RuntimeEnvironment.application; 114 mShadowApplication = shadowOf(application); 115 116 mShadowPackageManager = shadowOf(application.getPackageManager()); 117 118 Looper backupLooper = startBackupThreadAndGetLooper(); 119 mShadowBackupLooper = shadowOf(backupLooper); 120 121 Handler mainHandler = new Handler(Looper.getMainLooper()); 122 BackupAgentTimeoutParameters agentTimeoutParameters = 123 new BackupAgentTimeoutParameters(mainHandler, application.getContentResolver()); 124 agentTimeoutParameters.start(); 125 126 // We need to mock BMS timeout parameters before initializing the BackupHandler since 127 // the constructor of BackupHandler relies on it. 128 when(mBackupManagerService.getAgentTimeoutParameters()).thenReturn(agentTimeoutParameters); 129 BackupHandler backupHandler = new BackupHandler(mBackupManagerService, backupLooper); 130 131 mWakeLock = createBackupWakeLock(application); 132 133 setUpBackupManagerServiceBasics( 134 mBackupManagerService, 135 application, 136 mTransportManager, 137 application.getPackageManager(), 138 backupHandler, 139 mWakeLock, 140 agentTimeoutParameters); 141 when(mBackupManagerService.getPendingRestores()).thenReturn(new ArrayDeque<>()); 142 } 143 144 @After 145 public void tearDown() throws Exception { 146 ShadowPerformUnifiedRestoreTask.reset(); 147 } 148 149 @Test 150 public void testGetAvailableRestoreSets_withoutPermission() throws Exception { 151 mShadowApplication.denyPermissions(android.Manifest.permission.BACKUP); 152 setUpTransport(mTransport); 153 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 154 155 expectThrows( 156 SecurityException.class, 157 () -> restoreSession.getAvailableRestoreSets(mObserver, mMonitor)); 158 } 159 160 @Test 161 public void testGetAvailableRestoreSets_forNullObserver() throws Exception { 162 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 163 setUpTransport(mTransport); 164 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 165 166 expectThrows( 167 RuntimeException.class, 168 () -> restoreSession.getAvailableRestoreSets(null, mMonitor)); 169 } 170 171 @Test 172 public void testGetAvailableRestoreSets_whenTransportNotRegistered() throws Exception { 173 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 174 setUpTransport(mTransport.unregistered()); 175 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 176 177 int result = restoreSession.getAvailableRestoreSets(mObserver, mMonitor); 178 179 assertThat(result).isEqualTo(-1); 180 } 181 182 @Test 183 public void testGetAvailableRestoreSets() throws Exception { 184 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 185 TransportMock transportMock = setUpTransport(mTransport); 186 when(transportMock.transport.getAvailableRestoreSets()) 187 .thenReturn(new RestoreSet[] {mRestoreSet1, mRestoreSet2}); 188 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 189 190 int result = restoreSession.getAvailableRestoreSets(mObserver, mMonitor); 191 192 mShadowBackupLooper.runToEndOfTasks(); 193 assertThat(result).isEqualTo(0); 194 verify(mObserver) 195 .restoreSetsAvailable(aryEq(new RestoreSet[] {mRestoreSet1, mRestoreSet2})); 196 verify(mTransportManager) 197 .disposeOfTransportClient(eq(transportMock.transportClient), any()); 198 assertThat(mWakeLock.isHeld()).isFalse(); 199 } 200 201 @Test 202 public void testGetAvailableRestoreSets_forEmptyRestoreSets() throws Exception { 203 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 204 TransportMock transportMock = setUpTransport(mTransport); 205 when(transportMock.transport.getAvailableRestoreSets()).thenReturn(new RestoreSet[0]); 206 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 207 208 int result = restoreSession.getAvailableRestoreSets(mObserver, mMonitor); 209 210 mShadowBackupLooper.runToEndOfTasks(); 211 assertThat(result).isEqualTo(0); 212 verify(mObserver).restoreSetsAvailable(aryEq(new RestoreSet[0])); 213 assertThat(ShadowEventLog.hasEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE)).isFalse(); 214 } 215 216 @Test 217 public void testGetAvailableRestoreSets_forNullRestoreSets() throws Exception { 218 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 219 TransportMock transportMock = setUpTransport(mTransport); 220 when(transportMock.transport.getAvailableRestoreSets()).thenReturn(null); 221 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 222 223 int result = restoreSession.getAvailableRestoreSets(mObserver, mMonitor); 224 225 mShadowBackupLooper.runToEndOfTasks(); 226 assertThat(result).isEqualTo(0); 227 verify(mObserver).restoreSetsAvailable(isNull()); 228 assertThat(ShadowEventLog.hasEvent(EventLogTags.RESTORE_TRANSPORT_FAILURE)).isTrue(); 229 verify(mTransportManager) 230 .disposeOfTransportClient(eq(transportMock.transportClient), any()); 231 assertThat(mWakeLock.isHeld()).isFalse(); 232 } 233 234 @Test 235 public void testRestoreAll() throws Exception { 236 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 237 doCallRealMethod().when(mBackupManagerService).setRestoreInProgress(anyBoolean()); 238 when(mBackupManagerService.isRestoreInProgress()).thenCallRealMethod(); 239 TransportMock transportMock = setUpTransport(mTransport); 240 IRestoreSession restoreSession = 241 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 242 243 int result = restoreSession.restoreAll(TOKEN_1, mObserver, mMonitor); 244 245 mShadowBackupLooper.runToEndOfTasks(); 246 assertThat(result).isEqualTo(0); 247 verify(mTransportManager) 248 .disposeOfTransportClient(eq(transportMock.transportClient), any()); 249 assertThat(mWakeLock.isHeld()).isFalse(); 250 assertThat(mBackupManagerService.isRestoreInProgress()).isFalse(); 251 // Verify it created the task properly 252 ShadowPerformUnifiedRestoreTask shadowTask = 253 ShadowPerformUnifiedRestoreTask.getLastCreated(); 254 assertThat(shadowTask.isFullSystemRestore()).isTrue(); 255 assertThat(shadowTask.getFilterSet()).isNull(); 256 assertThat(shadowTask.getPackage()).isNull(); 257 } 258 259 @Test 260 public void testRestoreAll_whenNoRestoreSets() throws Exception { 261 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 262 setUpTransport(mTransport); 263 IRestoreSession restoreSession = createActiveRestoreSession(null, mTransport); 264 265 int result = restoreSession.restoreAll(TOKEN_1, mObserver, mMonitor); 266 267 assertThat(result).isEqualTo(-1); 268 } 269 270 @Test 271 public void testRestoreAll_whenSinglePackageSession() throws Exception { 272 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 273 setUpTransport(mTransport); 274 IRestoreSession restoreSession = 275 createActiveRestoreSessionWithRestoreSets(PACKAGE_1, mTransport, mRestoreSet1); 276 277 int result = restoreSession.restoreAll(TOKEN_1, mObserver, mMonitor); 278 279 assertThat(result).isEqualTo(-1); 280 } 281 282 @Test 283 public void testRestoreAll_whenSessionEnded() throws Exception { 284 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 285 setUpTransport(mTransport); 286 IRestoreSession restoreSession = 287 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 288 restoreSession.endRestoreSession(); 289 mShadowBackupLooper.runToEndOfTasks(); 290 291 expectThrows( 292 IllegalStateException.class, 293 () -> restoreSession.restoreAll(TOKEN_1, mObserver, mMonitor)); 294 } 295 296 @Test 297 public void testRestoreAll_whenTransportNotRegistered() throws Exception { 298 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 299 setUpTransport(mTransport.unregistered()); 300 IRestoreSession restoreSession = 301 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 302 303 int result = restoreSession.restoreAll(TOKEN_1, mObserver, mMonitor); 304 305 assertThat(result).isEqualTo(-1); 306 } 307 308 @Test 309 public void testRestoreAll_whenRestoreInProgress_addsToPendingRestores() throws Exception { 310 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 311 setUpTransport(mTransport); 312 when(mBackupManagerService.isRestoreInProgress()).thenReturn(true); 313 IRestoreSession restoreSession = 314 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 315 316 int result = restoreSession.restoreAll(TOKEN_1, mObserver, mMonitor); 317 318 mShadowBackupLooper.runToEndOfTasks(); 319 assertThat(result).isEqualTo(0); 320 assertThat(mBackupManagerService.getPendingRestores()).hasSize(1); 321 } 322 323 @Test 324 public void testRestoreSome_for2Packages() throws Exception { 325 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 326 TransportMock transportMock = setUpTransport(mTransport); 327 IRestoreSession restoreSession = 328 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 329 330 int result = 331 restoreSession.restoreSome( 332 TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1, PACKAGE_2}); 333 334 mShadowBackupLooper.runToEndOfTasks(); 335 assertThat(result).isEqualTo(0); 336 verify(mTransportManager) 337 .disposeOfTransportClient(eq(transportMock.transportClient), any()); 338 assertThat(mWakeLock.isHeld()).isFalse(); 339 assertThat(mBackupManagerService.isRestoreInProgress()).isFalse(); 340 ShadowPerformUnifiedRestoreTask shadowTask = 341 ShadowPerformUnifiedRestoreTask.getLastCreated(); 342 assertThat(shadowTask.getFilterSet()).asList().containsExactly(PACKAGE_1, PACKAGE_2); 343 assertThat(shadowTask.getPackage()).isNull(); 344 } 345 346 @Test 347 public void testRestoreSome_for2Packages_createsSystemRestoreTask() throws Exception { 348 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 349 setUpTransport(mTransport); 350 IRestoreSession restoreSession = 351 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 352 353 restoreSession.restoreSome( 354 TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1, PACKAGE_2}); 355 356 mShadowBackupLooper.runToEndOfTasks(); 357 assertThat(ShadowPerformUnifiedRestoreTask.getLastCreated().isFullSystemRestore()).isTrue(); 358 } 359 360 @Test 361 public void testRestoreSome_for1Package() throws Exception { 362 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 363 setUpTransport(mTransport); 364 IRestoreSession restoreSession = 365 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 366 367 restoreSession.restoreSome(TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1}); 368 369 mShadowBackupLooper.runToEndOfTasks(); 370 ShadowPerformUnifiedRestoreTask shadowTask = 371 ShadowPerformUnifiedRestoreTask.getLastCreated(); 372 assertThat(shadowTask.getFilterSet()).asList().containsExactly(PACKAGE_1); 373 assertThat(shadowTask.getPackage()).isNull(); 374 } 375 376 @Test 377 public void testRestoreSome_for1Package_createsNonSystemRestoreTask() throws Exception { 378 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 379 setUpTransport(mTransport); 380 IRestoreSession restoreSession = 381 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 382 383 restoreSession.restoreSome(TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1}); 384 385 mShadowBackupLooper.runToEndOfTasks(); 386 assertThat(ShadowPerformUnifiedRestoreTask.getLastCreated().isFullSystemRestore()) 387 .isFalse(); 388 } 389 390 @Test 391 public void testRestoreSome_whenNoRestoreSets() throws Exception { 392 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 393 setUpTransport(mTransport); 394 IRestoreSession restoreSession = createActiveRestoreSession(null, mTransport); 395 396 int result = 397 restoreSession.restoreSome(TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1}); 398 399 assertThat(result).isEqualTo(-1); 400 } 401 402 @Test 403 public void testRestoreSome_whenSinglePackageSession() throws Exception { 404 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 405 setUpTransport(mTransport); 406 IRestoreSession restoreSession = 407 createActiveRestoreSessionWithRestoreSets(PACKAGE_1, mTransport, mRestoreSet1); 408 409 int result = 410 restoreSession.restoreSome(TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_2}); 411 412 assertThat(result).isEqualTo(-1); 413 } 414 415 @Test 416 public void testRestoreSome_whenSessionEnded() throws Exception { 417 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 418 setUpTransport(mTransport); 419 IRestoreSession restoreSession = 420 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 421 restoreSession.endRestoreSession(); 422 mShadowBackupLooper.runToEndOfTasks(); 423 424 expectThrows( 425 IllegalStateException.class, 426 () -> 427 restoreSession.restoreSome( 428 TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1})); 429 } 430 431 @Test 432 public void testRestoreSome_whenTransportNotRegistered() throws Exception { 433 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 434 setUpTransport(mTransport.unregistered()); 435 IRestoreSession restoreSession = 436 createActiveRestoreSessionWithRestoreSets(null, mTransport, mRestoreSet1); 437 438 int result = 439 restoreSession.restoreSome(TOKEN_1, mObserver, mMonitor, new String[] {PACKAGE_1}); 440 441 assertThat(result).isEqualTo(-1); 442 } 443 444 @Test 445 public void testRestorePackage_whenCallerIsPackage() throws Exception { 446 // No need for BACKUP permission in this case 447 mShadowApplication.denyPermissions(android.Manifest.permission.BACKUP); 448 ShadowBinder.setCallingUid(1); 449 setUpPackage(PACKAGE_1, /* uid */ 1); 450 when(mBackupManagerService.getAvailableRestoreToken(PACKAGE_1)).thenReturn(TOKEN_1); 451 TransportMock transportMock = setUpTransport(mTransport); 452 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 453 454 int result = restoreSession.restorePackage(PACKAGE_1, mObserver, mMonitor); 455 456 mShadowBackupLooper.runToEndOfTasks(); 457 assertThat(result).isEqualTo(0); 458 verify(mTransportManager) 459 .disposeOfTransportClient(eq(transportMock.transportClient), any()); 460 assertThat(mWakeLock.isHeld()).isFalse(); 461 assertThat(mBackupManagerService.isRestoreInProgress()).isFalse(); 462 ShadowPerformUnifiedRestoreTask shadowTask = 463 ShadowPerformUnifiedRestoreTask.getLastCreated(); 464 assertThat(shadowTask.isFullSystemRestore()).isFalse(); 465 assertThat(shadowTask.getFilterSet()).isNull(); 466 assertThat(shadowTask.getPackage().packageName).isEqualTo(PACKAGE_1); 467 } 468 469 @Test 470 public void testRestorePackage_whenPackageNullWhenCreated() throws Exception { 471 ShadowBinder.setCallingUid(1); 472 setUpPackage(PACKAGE_1, /* uid */ 1); 473 when(mBackupManagerService.getAvailableRestoreToken(PACKAGE_1)).thenReturn(TOKEN_1); 474 setUpTransport(mTransport); 475 IRestoreSession restoreSession = createActiveRestoreSession(null, mTransport); 476 477 int result = restoreSession.restorePackage(PACKAGE_1, mObserver, mMonitor); 478 479 mShadowBackupLooper.runToEndOfTasks(); 480 assertThat(result).isEqualTo(0); 481 } 482 483 @Test 484 public void testRestorePackage_whenCallerIsNotPackageAndPermissionGranted() throws Exception { 485 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 486 ShadowBinder.setCallingUid(1); 487 setUpPackage(PACKAGE_1, /* uid */ 2); 488 when(mBackupManagerService.getAvailableRestoreToken(PACKAGE_1)).thenReturn(TOKEN_1); 489 setUpTransport(mTransport); 490 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 491 492 int result = restoreSession.restorePackage(PACKAGE_1, mObserver, mMonitor); 493 494 mShadowBackupLooper.runToEndOfTasks(); 495 assertThat(result).isEqualTo(0); 496 } 497 498 @Test 499 public void testRestorePackage_whenCallerIsNotPackageAndPermissionDenied() throws Exception { 500 mShadowApplication.denyPermissions(android.Manifest.permission.BACKUP); 501 ShadowBinder.setCallingUid(1); 502 setUpPackage(PACKAGE_1, /* uid */ 2); 503 when(mBackupManagerService.getAvailableRestoreToken(PACKAGE_1)).thenReturn(TOKEN_1); 504 setUpTransport(mTransport); 505 IRestoreSession restoreSession = createActiveRestoreSession(PACKAGE_1, mTransport); 506 507 expectThrows( 508 SecurityException.class, 509 () -> restoreSession.restorePackage(PACKAGE_1, mObserver, mMonitor)); 510 } 511 512 @Test 513 public void testRestorePackage_whenPackageNotFound() throws Exception { 514 mShadowApplication.grantPermissions(android.Manifest.permission.BACKUP); 515 setUpPackage(PACKAGE_1, /* uid */ 1); 516 setUpTransport(mTransport); 517 IRestoreSession restoreSession = createActiveRestoreSession(null, mTransport); 518 519 int result = restoreSession.restorePackage(PACKAGE_2, mObserver, mMonitor); 520 521 assertThat(result).isEqualTo(-1); 522 } 523 524 @Test 525 public void testRestorePackage_whenSessionEnded() throws Exception { 526 ShadowBinder.setCallingUid(1); 527 setUpPackage(PACKAGE_1, /* uid */ 1); 528 setUpTransport(mTransport); 529 IRestoreSession restoreSession = createActiveRestoreSession(null, mTransport); 530 restoreSession.endRestoreSession(); 531 mShadowBackupLooper.runToEndOfTasks(); 532 533 expectThrows( 534 IllegalStateException.class, 535 () -> restoreSession.restorePackage(PACKAGE_1, mObserver, mMonitor)); 536 } 537 538 @Test 539 public void testRestorePackage_whenTransportNotRegistered() throws Exception { 540 ShadowBinder.setCallingUid(1); 541 setUpPackage(PACKAGE_1, /* uid */ 1); 542 setUpTransport(mTransport.unregistered()); 543 IRestoreSession restoreSession = createActiveRestoreSession(null, mTransport); 544 545 int result = restoreSession.restorePackage(PACKAGE_1, mObserver, mMonitor); 546 547 assertThat(result).isEqualTo(-1); 548 } 549 550 // TODO: Create a builder for PackageInfo/ApplicationInfo and unify usage with 551 // TransportManagerTest 552 private void setUpPackage(String packageName, int uid) { 553 PackageInfo packageInfo = new PackageInfo(); 554 packageInfo.packageName = packageName; 555 packageInfo.applicationInfo = new ApplicationInfo(); 556 packageInfo.applicationInfo.uid = uid; 557 mShadowPackageManager.addPackage(packageInfo); 558 } 559 560 private IRestoreSession createActiveRestoreSession( 561 String packageName, TransportData transport) { 562 return new ActiveRestoreSession( 563 mBackupManagerService, packageName, transport.transportName); 564 } 565 566 private IRestoreSession createActiveRestoreSessionWithRestoreSets( 567 String packageName, TransportData transport, RestoreSet... restoreSets) 568 throws RemoteException { 569 ActiveRestoreSession restoreSession = 570 new ActiveRestoreSession( 571 mBackupManagerService, packageName, transport.transportName); 572 restoreSession.setRestoreSets(restoreSets); 573 return restoreSession; 574 } 575 576 private TransportMock setUpTransport(TransportData transport) throws Exception { 577 return TransportTestUtils.setUpTransport(mTransportManager, transport); 578 } 579 } 580
