1 /* 2 * Copyright (C) 2022 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 android.safetycenter.functional.multiusers 18 19 import android.Manifest.permission.INTERACT_ACROSS_USERS 20 import android.Manifest.permission.INTERACT_ACROSS_USERS_FULL 21 import android.app.PendingIntent 22 import android.content.Context 23 import android.content.Intent 24 import android.os.UserHandle 25 import android.safetycenter.SafetyCenterData 26 import android.safetycenter.SafetyCenterEntry.ENTRY_SEVERITY_LEVEL_CRITICAL_WARNING 27 import android.safetycenter.SafetyCenterEntry.ENTRY_SEVERITY_LEVEL_UNKNOWN 28 import android.safetycenter.SafetyCenterEntry.ENTRY_SEVERITY_LEVEL_UNSPECIFIED 29 import android.safetycenter.SafetyCenterEntry.SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 30 import android.safetycenter.SafetyCenterEntry.SEVERITY_UNSPECIFIED_ICON_TYPE_PRIVACY 31 import android.safetycenter.SafetyCenterEntryGroup 32 import android.safetycenter.SafetyCenterEntryOrGroup 33 import android.safetycenter.SafetyCenterManager 34 import android.safetycenter.SafetyCenterStaticEntry 35 import android.safetycenter.SafetyCenterStaticEntryGroup 36 import android.safetycenter.SafetyEvent 37 import android.safetycenter.SafetySourceData 38 import androidx.test.core.app.ApplicationProvider 39 import com.android.bedstead.harrier.BedsteadJUnit4 40 import com.android.bedstead.harrier.DeviceState 41 import com.android.bedstead.harrier.annotations.EnsureHasAdditionalUser 42 import com.android.bedstead.harrier.annotations.EnsureHasCloneProfile 43 import com.android.bedstead.harrier.annotations.EnsureHasNoWorkProfile 44 import com.android.bedstead.harrier.annotations.EnsureHasWorkProfile 45 import com.android.bedstead.harrier.annotations.Postsubmit 46 import com.android.bedstead.harrier.annotations.enterprise.EnsureHasDeviceOwner 47 import com.android.bedstead.nene.TestApis 48 import com.android.bedstead.nene.types.OptionalBoolean.TRUE 49 import com.android.compatibility.common.util.DisableAnimationRule 50 import com.android.compatibility.common.util.FreezeRotationRule 51 import com.android.safetycenter.resources.SafetyCenterResourcesContext 52 import com.android.safetycenter.testing.SafetyCenterActivityLauncher.launchSafetyCenterActivity 53 import com.android.safetycenter.testing.SafetyCenterApisWithShellPermissions.getSafetyCenterDataWithPermission 54 import com.android.safetycenter.testing.SafetyCenterApisWithShellPermissions.getSafetySourceDataWithPermission 55 import com.android.safetycenter.testing.SafetyCenterApisWithShellPermissions.setSafetySourceDataWithPermission 56 import com.android.safetycenter.testing.SafetyCenterFlags.deviceSupportsSafetyCenter 57 import com.android.safetycenter.testing.SafetyCenterTestConfigs 58 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.ACTION_TEST_ACTIVITY 59 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.DYNAMIC_BAREBONE_ID 60 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.DYNAMIC_DISABLED_ID 61 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.DYNAMIC_GROUP_ID 62 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.DYNAMIC_HIDDEN_ID 63 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.DYNAMIC_IN_STATELESS_ID 64 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.ISSUE_ONLY_ALL_OPTIONAL_ID 65 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.ISSUE_ONLY_ALL_PROFILE_SOURCE_ID 66 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.ISSUE_ONLY_BAREBONE_ID 67 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.ISSUE_ONLY_GROUP_ID 68 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.ISSUE_ONLY_IN_STATELESS_ID 69 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.MIXED_STATELESS_GROUP_ID 70 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.SINGLE_SOURCE_ALL_PROFILE_ID 71 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.SINGLE_SOURCE_GROUP_ID 72 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.SINGLE_SOURCE_ID 73 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.STATIC_ALL_OPTIONAL_ID 74 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.STATIC_BAREBONE_ID 75 import com.android.safetycenter.testing.SafetyCenterTestConfigs.Companion.STATIC_GROUP_ID 76 import com.android.safetycenter.testing.SafetyCenterTestData 77 import com.android.safetycenter.testing.SafetyCenterTestData.Companion.withoutExtras 78 import com.android.safetycenter.testing.SafetyCenterTestHelper 79 import com.android.safetycenter.testing.SafetySourceTestData 80 import com.android.safetycenter.testing.SafetySourceTestData.Companion.EVENT_SOURCE_STATE_CHANGED 81 import com.android.safetycenter.testing.ShellPermissions.callWithShellPermissionIdentity 82 import com.android.safetycenter.testing.UiTestHelper.waitAllTextDisplayed 83 import com.android.safetycenter.testing.UiTestHelper.waitAllTextNotDisplayed 84 import com.google.common.base.Preconditions.checkState 85 import com.google.common.truth.Truth.assertThat 86 import kotlin.test.assertFailsWith 87 import org.junit.After 88 import org.junit.Assume.assumeTrue 89 import org.junit.Before 90 import org.junit.ClassRule 91 import org.junit.Ignore 92 import org.junit.Rule 93 import org.junit.Test 94 import org.junit.runner.RunWith 95 96 /** 97 * Functional tests for our APIs and UI on a device with multiple users. e.g. with a managed or 98 * secondary user(s). 99 */ 100 @RunWith(BedsteadJUnit4::class) 101 class SafetyCenterMultiUsersTest { 102 103 companion object { 104 @JvmField @ClassRule @Rule val deviceState: DeviceState = DeviceState() 105 } 106 107 @get:Rule val disableAnimationRule = DisableAnimationRule() 108 109 @get:Rule val freezeRotationRule = FreezeRotationRule() 110 111 private val context: Context = ApplicationProvider.getApplicationContext() 112 private val safetyCenterResourcesContext = SafetyCenterResourcesContext.forTests(context) 113 private val safetyCenterTestHelper = SafetyCenterTestHelper(context) 114 private val safetySourceTestData = SafetySourceTestData(context) 115 private val safetyCenterTestData = SafetyCenterTestData(context) 116 private val safetyCenterTestConfigs = SafetyCenterTestConfigs(context) 117 private val safetyCenterManager = context.getSystemService(SafetyCenterManager::class.java)!! 118 119 // JUnit's Assume is not supported in @BeforeClass by the CTS tests runner, so this is used to 120 // manually skip the setup and teardown methods. 121 private val shouldRunTests = context.deviceSupportsSafetyCenter() 122 private var inQuietMode = false 123 124 private val primaryProfileOnlyIssues = 125 listOf( 126 safetyCenterTestData.safetyCenterIssueCritical( 127 DYNAMIC_BAREBONE_ID, 128 groupId = DYNAMIC_GROUP_ID 129 ), 130 safetyCenterTestData.safetyCenterIssueCritical( 131 ISSUE_ONLY_BAREBONE_ID, 132 attributionTitle = null, 133 groupId = ISSUE_ONLY_GROUP_ID 134 ), 135 safetyCenterTestData.safetyCenterIssueRecommendation( 136 DYNAMIC_DISABLED_ID, 137 groupId = DYNAMIC_GROUP_ID 138 ), 139 safetyCenterTestData.safetyCenterIssueRecommendation( 140 ISSUE_ONLY_ALL_OPTIONAL_ID, 141 attributionTitle = null, 142 groupId = ISSUE_ONLY_GROUP_ID 143 ), 144 safetyCenterTestData.safetyCenterIssueInformation( 145 DYNAMIC_IN_STATELESS_ID, 146 groupId = MIXED_STATELESS_GROUP_ID 147 ), 148 safetyCenterTestData.safetyCenterIssueInformation( 149 ISSUE_ONLY_IN_STATELESS_ID, 150 groupId = MIXED_STATELESS_GROUP_ID 151 ) 152 ) 153 154 private val dynamicBareboneDefault = 155 safetyCenterTestData.safetyCenterEntryDefault(DYNAMIC_BAREBONE_ID) 156 157 private val dynamicBareboneUpdated = 158 safetyCenterTestData.safetyCenterEntryCritical(DYNAMIC_BAREBONE_ID) 159 160 private val dynamicDisabledDefault = 161 safetyCenterTestData 162 .safetyCenterEntryDefaultBuilder(DYNAMIC_DISABLED_ID) 163 .setPendingIntent(null) 164 .setEnabled(false) 165 .build() 166 167 private val dynamicDisabledUpdated = 168 safetyCenterTestData.safetyCenterEntryRecommendation(DYNAMIC_DISABLED_ID) 169 170 private val dynamicDisabledForWorkDefaultBuilder 171 get() = 172 safetyCenterTestData 173 .safetyCenterEntryDefaultBuilder( 174 DYNAMIC_DISABLED_ID, 175 userId = deviceState.workProfile().id(), 176 title = "Paste" 177 ) 178 .setPendingIntent(null) 179 .setEnabled(false) 180 181 private val dynamicDisabledForWorkDefault 182 get() = dynamicDisabledForWorkDefaultBuilder.build() 183 184 private val dynamicDisabledForWorkPaused 185 get() = 186 dynamicDisabledForWorkDefaultBuilder 187 // TODO(b/233188021): This needs to use the Enterprise API to override the "work" 188 // keyword. 189 .setSummary(safetyCenterResourcesContext.getStringByName("work_profile_paused")) 190 .build() 191 192 private val dynamicDisabledForWorkUpdated 193 get() = safetyCenterEntryOkForWork(DYNAMIC_DISABLED_ID, deviceState.workProfile().id()) 194 195 private val dynamicHiddenUpdated = 196 safetyCenterTestData.safetyCenterEntryUnspecified(DYNAMIC_HIDDEN_ID, pendingIntent = null) 197 198 private val dynamicHiddenForWorkUpdated 199 get() = safetyCenterEntryOkForWork(DYNAMIC_HIDDEN_ID, deviceState.workProfile().id()) 200 201 private val staticGroupBuilder = 202 SafetyCenterEntryGroup.Builder(STATIC_GROUP_ID, "OK") 203 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_UNSPECIFIED) 204 .setSeverityUnspecifiedIconType(SEVERITY_UNSPECIFIED_ICON_TYPE_PRIVACY) 205 .setSummary("OK") 206 207 private val staticBarebone = 208 safetyCenterTestData 209 .safetyCenterEntryDefaultStaticBuilder(STATIC_BAREBONE_ID) 210 .setSummary(null) 211 .build() 212 213 private val staticAllOptional = 214 safetyCenterTestData.safetyCenterEntryDefaultStaticBuilder(STATIC_ALL_OPTIONAL_ID).build() 215 216 private val staticAllOptionalForWorkBuilder 217 get() = 218 safetyCenterTestData 219 .safetyCenterEntryDefaultStaticBuilder( 220 STATIC_ALL_OPTIONAL_ID, 221 userId = deviceState.workProfile().id(), 222 title = "Paste" 223 ) 224 .setPendingIntent( 225 createTestActivityRedirectPendingIntentForUser( 226 deviceState.workProfile().userHandle() 227 ) 228 ) 229 230 private val staticAllOptionalForWork 231 get() = staticAllOptionalForWorkBuilder.build() 232 233 private val staticAllOptionalForWorkPaused 234 get() = 235 staticAllOptionalForWorkBuilder 236 // TODO(b/233188021): This needs to use the Enterprise API to override the "work" 237 // keyword. 238 .setSummary(safetyCenterResourcesContext.getStringByName("work_profile_paused")) 239 .setEnabled(false) 240 .build() 241 242 private val staticEntry = 243 SafetyCenterStaticEntry.Builder("OK") 244 .setSummary("OK") 245 .setPendingIntent(safetySourceTestData.testActivityRedirectPendingIntent) 246 .build() 247 248 private val staticEntryUpdated = 249 SafetyCenterStaticEntry.Builder("Unspecified title") 250 .setSummary("Unspecified summary") 251 .setPendingIntent(safetySourceTestData.testActivityRedirectPendingIntent) 252 .build() 253 254 private val staticEntryForWorkBuilder 255 get() = 256 SafetyCenterStaticEntry.Builder("Paste") 257 .setSummary("OK") 258 .setPendingIntent( 259 createTestActivityRedirectPendingIntentForUser( 260 deviceState.workProfile().userHandle() 261 ) 262 ) 263 264 private val staticEntryForWork 265 get() = staticEntryForWorkBuilder.build() 266 267 private val staticEntryForWorkPaused 268 get() = 269 staticEntryForWorkBuilder 270 // TODO(b/233188021): This needs to use the Enterprise API to override the "work" 271 // keyword. 272 .setSummary(safetyCenterResourcesContext.getStringByName("work_profile_paused")) 273 .build() 274 275 private val staticEntryForWorkUpdated = 276 SafetyCenterStaticEntry.Builder("Unspecified title for Work") 277 .setSummary("Unspecified summary") 278 .setPendingIntent(safetySourceTestData.testActivityRedirectPendingIntent) 279 .build() 280 281 private val safetyCenterDataForAdditionalUser 282 get() = 283 SafetyCenterData( 284 safetyCenterTestData.safetyCenterStatusUnknown, 285 emptyList(), 286 listOf( 287 SafetyCenterEntryOrGroup( 288 safetyCenterTestData.safetyCenterEntryDefault( 289 SINGLE_SOURCE_ALL_PROFILE_ID, 290 deviceState.additionalUser().id(), 291 pendingIntent = 292 createTestActivityRedirectPendingIntentForUser( 293 deviceState.additionalUser().userHandle() 294 ) 295 ) 296 ) 297 ), 298 emptyList() 299 ) 300 301 @Before assumeDeviceSupportsSafetyCenterToRunTestsnull302 fun assumeDeviceSupportsSafetyCenterToRunTests() { 303 assumeTrue(shouldRunTests) 304 } 305 306 @Before enableSafetyCenterBeforeTestnull307 fun enableSafetyCenterBeforeTest() { 308 if (!shouldRunTests) { 309 return 310 } 311 safetyCenterTestHelper.setup() 312 } 313 314 @After clearDataAfterTestnull315 fun clearDataAfterTest() { 316 if (!shouldRunTests) { 317 return 318 } 319 safetyCenterTestHelper.reset() 320 resetQuietMode() 321 } 322 323 @Test 324 @EnsureHasWorkProfile 325 @Ignore 326 // Tests that check the UI takes a lot of time and they might get timeout in the postsubmits. 327 // TODO(b/242999951): Write this test using the APIs instead of checking the UI. launchActivity_withProfileOwner_displaysWorkPolicyInfonull328 fun launchActivity_withProfileOwner_displaysWorkPolicyInfo() { 329 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.workPolicyInfoConfig) 330 331 findWorkPolicyInfo() 332 } 333 334 @Test 335 @EnsureHasDeviceOwner 336 @Ignore 337 // Tests that check the UI takes a lot of time and they might get timeout in the postsubmits. 338 // TODO(b/242999951): Write this test using the APIs instead of checking the UI. launchActivity_withDeviceOwner_displaysWorkPolicyInfonull339 fun launchActivity_withDeviceOwner_displaysWorkPolicyInfo() { 340 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.workPolicyInfoConfig) 341 342 findWorkPolicyInfo() 343 } 344 345 @Test 346 @EnsureHasWorkProfile 347 @Ignore 348 // Tests that check the UI takes a lot of time and they might get timeout in the postsubmits. 349 // TODO(b/242999951): Write this test using the APIs instead of checking the UI. launchActivity_withQuietModeEnabled_shouldNotDisplayWorkPolicyInfonull350 fun launchActivity_withQuietModeEnabled_shouldNotDisplayWorkPolicyInfo() { 351 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.workPolicyInfoConfig) 352 353 findWorkPolicyInfo() 354 setQuietMode(true) 355 context.launchSafetyCenterActivity { waitAllTextNotDisplayed("Your work policy info") } 356 } 357 358 @Test 359 @Ignore 360 // Test involving toggling of quiet mode are flaky. 361 // TODO(b/237365018): Re-enable them back once we figure out a way to make them stable. 362 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetySourceData_withQuietModeEnabled_dataIsNotClearednull363 fun getSafetySourceData_withQuietModeEnabled_dataIsNotCleared() { 364 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 365 val dataForWork = safetySourceTestData.informationWithIssueForWork 366 val managedSafetyCenterManager = 367 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 368 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 369 SINGLE_SOURCE_ALL_PROFILE_ID, 370 dataForWork 371 ) 372 373 setQuietMode(true) 374 val apiSafetySourceDataForWork = 375 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 376 SINGLE_SOURCE_ALL_PROFILE_ID 377 ) 378 379 assertThat(apiSafetySourceDataForWork).isEqualTo(dataForWork) 380 } 381 382 @Test 383 @EnsureHasAdditionalUser(installInstrumentedApp = TRUE) 384 @Postsubmit(reason = "Test takes too much time to setup") getSafetySourceData_afterAdditionalUserRemoved_returnsNullnull385 fun getSafetySourceData_afterAdditionalUserRemoved_returnsNull() { 386 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 387 val additionalUserSafetyCenterManager = 388 getSafetyCenterManagerForUser(deviceState.additionalUser().userHandle()) 389 val dataForAdditionalUser = safetySourceTestData.information 390 additionalUserSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 391 SINGLE_SOURCE_ALL_PROFILE_ID, 392 dataForAdditionalUser 393 ) 394 checkState( 395 additionalUserSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 396 SINGLE_SOURCE_ALL_PROFILE_ID 397 ) == dataForAdditionalUser 398 ) 399 400 deviceState.additionalUser().remove() 401 402 assertThat( 403 additionalUserSafetyCenterManager 404 .getSafetySourceDataWithInteractAcrossUsersPermission( 405 SINGLE_SOURCE_ALL_PROFILE_ID 406 ) 407 ) 408 .isNull() 409 } 410 411 @Test 412 @Postsubmit(reason = "Test takes too much time to setup") 413 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetySourceData_withoutInteractAcrossUserPermission_shouldThrowErrornull414 fun getSafetySourceData_withoutInteractAcrossUserPermission_shouldThrowError() { 415 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 416 417 val managedSafetyCenterManager = 418 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 419 assertFailsWith(SecurityException::class) { 420 managedSafetyCenterManager.getSafetySourceData(SINGLE_SOURCE_ALL_PROFILE_ID) 421 } 422 } 423 424 @Test 425 @Postsubmit(reason = "Test takes too much time to setup") 426 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetySourceData_withoutAppInstalledForWorkProfile_shouldReturnNullnull427 fun getSafetySourceData_withoutAppInstalledForWorkProfile_shouldReturnNull() { 428 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 429 val managedSafetyCenterManager = 430 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 431 val dataForWork = safetySourceTestData.informationWithIssueForWork 432 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 433 SINGLE_SOURCE_ALL_PROFILE_ID, 434 dataForWork 435 ) 436 TestApis.packages().find(context.packageName).uninstall(deviceState.workProfile()) 437 438 val safetySourceData = 439 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 440 SINGLE_SOURCE_ALL_PROFILE_ID 441 ) 442 443 assertThat(safetySourceData).isNull() 444 } 445 446 @Test 447 @Postsubmit(reason = "Test takes too much time to setup") 448 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetySourceData_withRemovedProfile_shouldReturnNullnull449 fun getSafetySourceData_withRemovedProfile_shouldReturnNull() { 450 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 451 val managedSafetyCenterManager = 452 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 453 val dataForWork = safetySourceTestData.informationWithIssueForWork 454 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 455 SINGLE_SOURCE_ALL_PROFILE_ID, 456 dataForWork 457 ) 458 deviceState.workProfile().remove() 459 460 val safetySourceData = 461 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 462 SINGLE_SOURCE_ALL_PROFILE_ID 463 ) 464 465 assertThat(safetySourceData).isNull() 466 } 467 468 @Test 469 @Postsubmit(reason = "Test takes too much time to setup") 470 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) 471 @Ignore 472 // Test involving toggling of quiet mode are flaky. getSafetySourceData_withProfileInQuietMode_shouldReturnDatanull473 fun getSafetySourceData_withProfileInQuietMode_shouldReturnData() { 474 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 475 val managedSafetyCenterManager = 476 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 477 val dataForWork = safetySourceTestData.informationWithIssueForWork 478 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 479 SINGLE_SOURCE_ALL_PROFILE_ID, 480 dataForWork 481 ) 482 setQuietMode(true) 483 484 val safetySourceData = 485 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 486 SINGLE_SOURCE_ALL_PROFILE_ID 487 ) 488 489 assertThat(safetySourceData).isEqualTo(dataForWork) 490 } 491 492 @Test 493 @Postsubmit(reason = "Test takes too much time to setup") 494 @EnsureHasNoWorkProfile getSafetyCenterData_withComplexConfigWithoutWorkProfile_returnsPrimaryDataFromConfignull495 fun getSafetyCenterData_withComplexConfigWithoutWorkProfile_returnsPrimaryDataFromConfig() { 496 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.complexAllProfileConfig) 497 498 val apiSafetyCenterData = safetyCenterManager.getSafetyCenterDataWithPermission() 499 500 val safetyCenterDataFromComplexConfig = 501 SafetyCenterData( 502 safetyCenterTestData.safetyCenterStatusUnknown, 503 emptyList(), 504 listOf( 505 SafetyCenterEntryOrGroup( 506 SafetyCenterEntryGroup.Builder(DYNAMIC_GROUP_ID, "OK") 507 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_UNKNOWN) 508 .setSummary( 509 safetyCenterResourcesContext.getStringByName( 510 "group_unknown_summary" 511 ) 512 ) 513 .setEntries(listOf(dynamicBareboneDefault, dynamicDisabledDefault)) 514 .setSeverityUnspecifiedIconType( 515 SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 516 ) 517 .build() 518 ), 519 SafetyCenterEntryOrGroup( 520 staticGroupBuilder 521 .setEntries(listOf(staticBarebone, staticAllOptional)) 522 .build() 523 ) 524 ), 525 listOf(SafetyCenterStaticEntryGroup("OK", listOf(staticEntry, staticEntry))) 526 ) 527 assertThat(apiSafetyCenterData.withoutExtras()).isEqualTo(safetyCenterDataFromComplexConfig) 528 } 529 530 @Test 531 @Postsubmit(reason = "Test takes too much time to setup") 532 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetyCenterData_withComplexConfigWithoutDataProvided_returnsDataFromConfignull533 fun getSafetyCenterData_withComplexConfigWithoutDataProvided_returnsDataFromConfig() { 534 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.complexAllProfileConfig) 535 536 val apiSafetyCenterData = safetyCenterManager.getSafetyCenterDataWithPermission() 537 538 val safetyCenterDataFromComplexConfig = 539 SafetyCenterData( 540 safetyCenterTestData.safetyCenterStatusUnknown, 541 emptyList(), 542 listOf( 543 SafetyCenterEntryOrGroup( 544 SafetyCenterEntryGroup.Builder(DYNAMIC_GROUP_ID, "OK") 545 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_UNKNOWN) 546 .setSummary( 547 safetyCenterResourcesContext.getStringByName( 548 "group_unknown_summary" 549 ) 550 ) 551 .setEntries( 552 listOf( 553 dynamicBareboneDefault, 554 dynamicDisabledDefault, 555 dynamicDisabledForWorkDefault 556 ) 557 ) 558 .setSeverityUnspecifiedIconType( 559 SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 560 ) 561 .build() 562 ), 563 SafetyCenterEntryOrGroup( 564 staticGroupBuilder 565 .setEntries( 566 listOf(staticBarebone, staticAllOptional, staticAllOptionalForWork) 567 ) 568 .build() 569 ) 570 ), 571 listOf( 572 SafetyCenterStaticEntryGroup( 573 "OK", 574 listOf(staticEntry, staticEntryForWork, staticEntry, staticEntryForWork) 575 ) 576 ) 577 ) 578 assertThat(apiSafetyCenterData.withoutExtras()).isEqualTo(safetyCenterDataFromComplexConfig) 579 } 580 581 @Test 582 @Postsubmit(reason = "Test takes too much time to setup") 583 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetyCenterData_withComplexConfigWithPrimaryDataProvided_returnsPrimaryDataProvidednull584 fun getSafetyCenterData_withComplexConfigWithPrimaryDataProvided_returnsPrimaryDataProvided() { 585 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.complexAllProfileConfig) 586 updatePrimaryProfileSources() 587 588 val apiSafetyCenterData = safetyCenterManager.getSafetyCenterDataWithPermission() 589 590 val safetyCenterDataFromComplexConfig = 591 SafetyCenterData( 592 safetyCenterTestData.safetyCenterStatusCritical(6), 593 primaryProfileOnlyIssues, 594 listOf( 595 SafetyCenterEntryOrGroup( 596 SafetyCenterEntryGroup.Builder(DYNAMIC_GROUP_ID, "OK") 597 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_CRITICAL_WARNING) 598 .setSummary("Critical summary") 599 .setEntries( 600 listOf( 601 dynamicBareboneUpdated, 602 dynamicDisabledUpdated, 603 dynamicDisabledForWorkDefault, 604 dynamicHiddenUpdated 605 ) 606 ) 607 .setSeverityUnspecifiedIconType( 608 SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 609 ) 610 .build() 611 ), 612 SafetyCenterEntryOrGroup( 613 staticGroupBuilder 614 .setEntries( 615 listOf(staticBarebone, staticAllOptional, staticAllOptionalForWork) 616 ) 617 .build() 618 ) 619 ), 620 listOf( 621 SafetyCenterStaticEntryGroup( 622 "OK", 623 listOf( 624 staticEntryUpdated, 625 staticEntryForWork, 626 staticEntry, 627 staticEntryForWork 628 ) 629 ) 630 ) 631 ) 632 assertThat(apiSafetyCenterData.withoutExtras()).isEqualTo(safetyCenterDataFromComplexConfig) 633 } 634 635 @Test 636 @Postsubmit(reason = "Test takes too much time to setup") 637 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetyCenterData_withComplexConfigWithAllDataProvided_returnsAllDataProvidednull638 fun getSafetyCenterData_withComplexConfigWithAllDataProvided_returnsAllDataProvided() { 639 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.complexAllProfileConfig) 640 updatePrimaryProfileSources() 641 updateWorkProfileSources() 642 643 val apiSafetyCenterData = safetyCenterManager.getSafetyCenterDataWithPermission() 644 645 val managedUserId = deviceState.workProfile().id() 646 val safetyCenterDataFromComplexConfig = 647 SafetyCenterData( 648 safetyCenterTestData.safetyCenterStatusCritical(11), 649 listOf( 650 safetyCenterTestData.safetyCenterIssueCritical( 651 DYNAMIC_BAREBONE_ID, 652 groupId = DYNAMIC_GROUP_ID 653 ), 654 safetyCenterTestData.safetyCenterIssueCritical( 655 ISSUE_ONLY_BAREBONE_ID, 656 attributionTitle = null, 657 groupId = ISSUE_ONLY_GROUP_ID 658 ), 659 safetyCenterTestData.safetyCenterIssueRecommendation( 660 DYNAMIC_DISABLED_ID, 661 groupId = DYNAMIC_GROUP_ID 662 ), 663 safetyCenterTestData.safetyCenterIssueRecommendation( 664 ISSUE_ONLY_ALL_OPTIONAL_ID, 665 attributionTitle = null, 666 groupId = ISSUE_ONLY_GROUP_ID 667 ), 668 safetyCenterTestData.safetyCenterIssueInformation( 669 DYNAMIC_IN_STATELESS_ID, 670 groupId = MIXED_STATELESS_GROUP_ID 671 ), 672 safetyCenterTestData.safetyCenterIssueInformation( 673 ISSUE_ONLY_IN_STATELESS_ID, 674 groupId = MIXED_STATELESS_GROUP_ID 675 ), 676 safetyCenterTestData.safetyCenterIssueInformation( 677 DYNAMIC_DISABLED_ID, 678 managedUserId, 679 groupId = DYNAMIC_GROUP_ID 680 ), 681 safetyCenterTestData.safetyCenterIssueInformation( 682 DYNAMIC_HIDDEN_ID, 683 managedUserId, 684 groupId = DYNAMIC_GROUP_ID 685 ), 686 safetyCenterTestData.safetyCenterIssueInformation( 687 ISSUE_ONLY_ALL_OPTIONAL_ID, 688 managedUserId, 689 attributionTitle = null, 690 groupId = ISSUE_ONLY_GROUP_ID 691 ), 692 safetyCenterTestData.safetyCenterIssueInformation( 693 DYNAMIC_IN_STATELESS_ID, 694 managedUserId, 695 groupId = MIXED_STATELESS_GROUP_ID 696 ), 697 safetyCenterTestData.safetyCenterIssueInformation( 698 ISSUE_ONLY_IN_STATELESS_ID, 699 managedUserId, 700 groupId = MIXED_STATELESS_GROUP_ID 701 ) 702 ), 703 listOf( 704 SafetyCenterEntryOrGroup( 705 SafetyCenterEntryGroup.Builder(DYNAMIC_GROUP_ID, "OK") 706 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_CRITICAL_WARNING) 707 .setSummary("Critical summary") 708 .setEntries( 709 listOf( 710 dynamicBareboneUpdated, 711 dynamicDisabledUpdated, 712 dynamicDisabledForWorkUpdated, 713 dynamicHiddenUpdated, 714 dynamicHiddenForWorkUpdated 715 ) 716 ) 717 .setSeverityUnspecifiedIconType( 718 SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 719 ) 720 .build() 721 ), 722 SafetyCenterEntryOrGroup( 723 staticGroupBuilder 724 .setEntries( 725 listOf(staticBarebone, staticAllOptional, staticAllOptionalForWork) 726 ) 727 .build() 728 ) 729 ), 730 listOf( 731 SafetyCenterStaticEntryGroup( 732 "OK", 733 listOf( 734 staticEntryUpdated, 735 staticEntryForWorkUpdated, 736 staticEntry, 737 staticEntryForWork 738 ) 739 ) 740 ) 741 ) 742 assertThat(apiSafetyCenterData.withoutExtras()).isEqualTo(safetyCenterDataFromComplexConfig) 743 } 744 745 @Test 746 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) 747 @Ignore 748 // Test involving toggling of quiet mode are flaky. 749 // TODO(b/237365018): Re-enable them back once we figure out a way to make them stable. getSafetyCenterData_withQuietMode_shouldHaveWorkProfilePausedSummaryAndNoWorkIssuesnull750 fun getSafetyCenterData_withQuietMode_shouldHaveWorkProfilePausedSummaryAndNoWorkIssues() { 751 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.complexAllProfileConfig) 752 updatePrimaryProfileSources() 753 updateWorkProfileSources() 754 755 setQuietMode(true) 756 val apiSafetyCenterData = safetyCenterManager.getSafetyCenterDataWithPermission() 757 758 val safetyCenterDataFromComplexConfig = 759 SafetyCenterData( 760 safetyCenterTestData.safetyCenterStatusCritical(6), 761 primaryProfileOnlyIssues, 762 listOf( 763 SafetyCenterEntryOrGroup( 764 SafetyCenterEntryGroup.Builder(DYNAMIC_GROUP_ID, "OK") 765 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_CRITICAL_WARNING) 766 .setSummary("Critical summary") 767 .setEntries( 768 listOf( 769 dynamicBareboneUpdated, 770 dynamicDisabledUpdated, 771 dynamicDisabledForWorkPaused, 772 dynamicHiddenUpdated 773 ) 774 ) 775 .setSeverityUnspecifiedIconType( 776 SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 777 ) 778 .build() 779 ), 780 SafetyCenterEntryOrGroup( 781 staticGroupBuilder 782 .setEntries( 783 listOf( 784 staticBarebone, 785 staticAllOptional, 786 staticAllOptionalForWorkPaused 787 ) 788 ) 789 .build() 790 ) 791 ), 792 listOf( 793 SafetyCenterStaticEntryGroup( 794 "OK", 795 listOf( 796 staticEntryUpdated, 797 staticEntryForWorkPaused, 798 staticEntry, 799 staticEntryForWorkPaused 800 ) 801 ) 802 ) 803 ) 804 assertThat(apiSafetyCenterData.withoutExtras()).isEqualTo(safetyCenterDataFromComplexConfig) 805 } 806 807 @Test 808 @EnsureHasAdditionalUser(installInstrumentedApp = TRUE) 809 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) 810 @Postsubmit(reason = "Test takes too much time to setup") getSafetyCenterData_withDataForDifferentUserProfileGroup_shouldBeUnaffectednull811 fun getSafetyCenterData_withDataForDifferentUserProfileGroup_shouldBeUnaffected() { 812 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 813 val dataForPrimaryUser = safetySourceTestData.information 814 safetyCenterTestHelper.setData(SINGLE_SOURCE_ALL_PROFILE_ID, dataForPrimaryUser) 815 val dataForPrimaryUserWorkProfile = safetySourceTestData.informationWithIssueForWork 816 val managedSafetyCenterManager = 817 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 818 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 819 SINGLE_SOURCE_ALL_PROFILE_ID, 820 dataForPrimaryUserWorkProfile 821 ) 822 823 val additionalUserSafetyCenterManager = 824 getSafetyCenterManagerForUser(deviceState.additionalUser().userHandle()) 825 val apiSafetyCenterDataForAdditionalUser = 826 additionalUserSafetyCenterManager.getSafetyCenterDataWithInteractAcrossUsersPermission() 827 828 assertThat(apiSafetyCenterDataForAdditionalUser) 829 .isEqualTo(safetyCenterDataForAdditionalUser) 830 } 831 832 @Test 833 @Ignore // Removing a managed profile causes a refresh, which makes some tests flaky. 834 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) getSafetyCenterData_afterManagedProfileRemoved_returnsDefaultDatanull835 fun getSafetyCenterData_afterManagedProfileRemoved_returnsDefaultData() { 836 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 837 val managedSafetyCenterManager = 838 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 839 val safetyCenterDataWithWorkProfile = 840 SafetyCenterData( 841 safetyCenterTestData.safetyCenterStatusUnknown, 842 emptyList(), 843 listOf( 844 SafetyCenterEntryOrGroup( 845 SafetyCenterEntryGroup.Builder(SINGLE_SOURCE_GROUP_ID, "OK") 846 .setSeverityLevel(ENTRY_SEVERITY_LEVEL_UNKNOWN) 847 .setSummary( 848 safetyCenterResourcesContext.getStringByName( 849 "group_unknown_summary" 850 ) 851 ) 852 .setEntries( 853 listOf( 854 safetyCenterTestData.safetyCenterEntryDefault( 855 SINGLE_SOURCE_ALL_PROFILE_ID 856 ), 857 safetyCenterTestData.safetyCenterEntryDefault( 858 SINGLE_SOURCE_ALL_PROFILE_ID, 859 deviceState.workProfile().id(), 860 title = "Paste", 861 pendingIntent = 862 createTestActivityRedirectPendingIntentForUser( 863 deviceState.workProfile().userHandle() 864 ) 865 ) 866 ) 867 ) 868 .setSeverityUnspecifiedIconType( 869 SEVERITY_UNSPECIFIED_ICON_TYPE_NO_RECOMMENDATION 870 ) 871 .build() 872 ) 873 ), 874 emptyList() 875 ) 876 checkState( 877 safetyCenterManager.getSafetyCenterDataWithPermission() == 878 safetyCenterDataWithWorkProfile 879 ) 880 checkState( 881 managedSafetyCenterManager.getSafetyCenterDataWithInteractAcrossUsersPermission() == 882 safetyCenterDataWithWorkProfile 883 ) 884 885 deviceState.workProfile().remove() 886 887 val safetyCenterDataForPrimaryUser = 888 SafetyCenterData( 889 safetyCenterTestData.safetyCenterStatusUnknown, 890 emptyList(), 891 listOf( 892 SafetyCenterEntryOrGroup( 893 safetyCenterTestData.safetyCenterEntryDefault(SINGLE_SOURCE_ALL_PROFILE_ID) 894 ) 895 ), 896 emptyList() 897 ) 898 assertThat(safetyCenterManager.getSafetyCenterDataWithPermission()) 899 .isEqualTo(safetyCenterDataForPrimaryUser) 900 assertThat( 901 managedSafetyCenterManager.getSafetyCenterDataWithInteractAcrossUsersPermission() 902 ) 903 .isEqualTo(SafetyCenterTestData.DEFAULT) 904 } 905 906 @Test 907 @EnsureHasAdditionalUser(installInstrumentedApp = TRUE) 908 @Postsubmit(reason = "Test takes too much time to setup") getSafetyCenterData_afterAdditionalUserRemoved_returnsDefaultDatanull909 fun getSafetyCenterData_afterAdditionalUserRemoved_returnsDefaultData() { 910 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 911 val additionalUserSafetyCenterManager = 912 getSafetyCenterManagerForUser(deviceState.additionalUser().userHandle()) 913 checkState( 914 additionalUserSafetyCenterManager 915 .getSafetyCenterDataWithInteractAcrossUsersPermission() == 916 safetyCenterDataForAdditionalUser 917 ) 918 919 deviceState.additionalUser().remove() 920 921 assertThat( 922 additionalUserSafetyCenterManager 923 .getSafetyCenterDataWithInteractAcrossUsersPermission() 924 ) 925 .isEqualTo(SafetyCenterTestData.DEFAULT) 926 } 927 928 @Test 929 @Postsubmit(reason = "Test takes too much time to setup") 930 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_primaryProfileIssueOnlySource_shouldNotBeAbleToSetDataToWorkProfilenull931 fun setSafetySourceData_primaryProfileIssueOnlySource_shouldNotBeAbleToSetDataToWorkProfile() { 932 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.issueOnlySourceConfig) 933 val managedSafetyCenterManager = 934 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 935 val dataForWork = 936 SafetySourceTestData.issuesOnly(safetySourceTestData.criticalResolvingGeneralIssue) 937 938 assertFailsWith(IllegalArgumentException::class) { 939 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 940 ISSUE_ONLY_ALL_OPTIONAL_ID, 941 dataForWork 942 ) 943 } 944 } 945 946 @Test 947 @Postsubmit(reason = "Test takes too much time to setup") 948 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_withoutInteractAcrossUserPermission_shouldThrowErrornull949 fun setSafetySourceData_withoutInteractAcrossUserPermission_shouldThrowError() { 950 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 951 val dataForWork = safetySourceTestData.informationWithIssueForWork 952 val managedSafetyCenterManager = 953 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 954 955 assertFailsWith(SecurityException::class) { 956 managedSafetyCenterManager.setSafetySourceData( 957 SINGLE_SOURCE_ALL_PROFILE_ID, 958 dataForWork, 959 EVENT_SOURCE_STATE_CHANGED 960 ) 961 } 962 } 963 964 @Test 965 @Postsubmit(reason = "Test takes too much time to setup") 966 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_withoutAppInstalledForWorkProfile_shouldNoOpnull967 fun setSafetySourceData_withoutAppInstalledForWorkProfile_shouldNoOp() { 968 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 969 val dataForWork = safetySourceTestData.informationWithIssueForWork 970 val managedSafetyCenterManager = 971 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 972 TestApis.packages().find(context.packageName).uninstall(deviceState.workProfile()) 973 974 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 975 SINGLE_SOURCE_ALL_PROFILE_ID, 976 dataForWork 977 ) 978 979 val safetySourceData = 980 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 981 SINGLE_SOURCE_ALL_PROFILE_ID 982 ) 983 assertThat(safetySourceData).isNull() 984 } 985 986 @Test 987 @Postsubmit(reason = "Test takes too much time to setup") 988 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_withRemovedProfile_shouldNoOpnull989 fun setSafetySourceData_withRemovedProfile_shouldNoOp() { 990 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 991 val dataForWork = safetySourceTestData.informationWithIssueForWork 992 val managedSafetyCenterManager = 993 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 994 deviceState.workProfile().remove() 995 996 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 997 SINGLE_SOURCE_ALL_PROFILE_ID, 998 dataForWork 999 ) 1000 1001 val safetySourceData = 1002 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1003 SINGLE_SOURCE_ALL_PROFILE_ID 1004 ) 1005 assertThat(safetySourceData).isNull() 1006 } 1007 1008 @Test 1009 @Postsubmit(reason = "Test takes too much time to setup") 1010 @EnsureHasCloneProfile(installInstrumentedApp = TRUE) setSafetySourceData_withUnsupportedProfile_shouldNoOpnull1011 fun setSafetySourceData_withUnsupportedProfile_shouldNoOp() { 1012 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 1013 val dataForClone = safetySourceTestData.informationWithIssueForWork 1014 val clonedSafetyCenterManager = 1015 getSafetyCenterManagerForUser(deviceState.cloneProfile().userHandle()) 1016 1017 clonedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1018 SINGLE_SOURCE_ALL_PROFILE_ID, 1019 dataForClone 1020 ) 1021 1022 val safetySourceData = 1023 clonedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1024 SINGLE_SOURCE_ALL_PROFILE_ID 1025 ) 1026 assertThat(safetySourceData).isNull() 1027 } 1028 1029 @Test 1030 @Postsubmit(reason = "Test takes too much time to setup") 1031 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) 1032 @Ignore 1033 // Test involving toggling of quiet mode are flaky. setSafetySourceData_withProfileInQuietMode_shouldSetDatanull1034 fun setSafetySourceData_withProfileInQuietMode_shouldSetData() { 1035 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 1036 val dataForWork = safetySourceTestData.informationWithIssueForWork 1037 val managedSafetyCenterManager = 1038 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 1039 setQuietMode(true) 1040 1041 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1042 SINGLE_SOURCE_ALL_PROFILE_ID, 1043 dataForWork 1044 ) 1045 1046 val safetySourceData = 1047 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1048 SINGLE_SOURCE_ALL_PROFILE_ID 1049 ) 1050 assertThat(safetySourceData).isEqualTo(dataForWork) 1051 } 1052 1053 @Test 1054 @Postsubmit(reason = "Test takes too much time to setup") 1055 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_issuesOnlySourceWithWorkProfile_shouldBeAbleToSetDatanull1056 fun setSafetySourceData_issuesOnlySourceWithWorkProfile_shouldBeAbleToSetData() { 1057 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.issueOnlySourceAllProfileConfig) 1058 1059 val dataForPrimaryUser = 1060 SafetySourceTestData.issuesOnly(safetySourceTestData.recommendationGeneralIssue) 1061 safetyCenterTestHelper.setData(ISSUE_ONLY_ALL_PROFILE_SOURCE_ID, dataForPrimaryUser) 1062 val managedSafetyCenterManager = 1063 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 1064 val dataForWorkProfile = 1065 SafetySourceTestData.issuesOnly(safetySourceTestData.criticalResolvingGeneralIssue) 1066 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1067 ISSUE_ONLY_ALL_PROFILE_SOURCE_ID, 1068 dataForWorkProfile 1069 ) 1070 1071 val apiSafetySourceData = 1072 safetyCenterManager.getSafetySourceDataWithPermission(ISSUE_ONLY_ALL_PROFILE_SOURCE_ID) 1073 val apiSafetySourceDataForWork = 1074 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1075 ISSUE_ONLY_ALL_PROFILE_SOURCE_ID 1076 ) 1077 assertThat(apiSafetySourceData).isEqualTo(dataForPrimaryUser) 1078 assertThat(apiSafetySourceDataForWork).isEqualTo(dataForWorkProfile) 1079 } 1080 1081 @Test 1082 @Postsubmit(reason = "Test takes too much time to setup") 1083 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_primaryProfileSource_shouldNotBeAbleToSetDataToWorkProfilenull1084 fun setSafetySourceData_primaryProfileSource_shouldNotBeAbleToSetDataToWorkProfile() { 1085 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceConfig) 1086 1087 val managedSafetyCenterManager = 1088 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 1089 val dataForWork = safetySourceTestData.informationWithIssueForWork 1090 assertFailsWith(IllegalArgumentException::class) { 1091 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1092 SINGLE_SOURCE_ID, 1093 dataForWork 1094 ) 1095 } 1096 } 1097 1098 @Test 1099 @Postsubmit(reason = "Test takes too much time to setup") 1100 @EnsureHasWorkProfile(installInstrumentedApp = TRUE) setSafetySourceData_sourceWithWorkProfile_shouldBeAbleToSetDatanull1101 fun setSafetySourceData_sourceWithWorkProfile_shouldBeAbleToSetData() { 1102 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceAllProfileConfig) 1103 1104 val dataForPrimaryUser = safetySourceTestData.information 1105 safetyCenterTestHelper.setData(SINGLE_SOURCE_ALL_PROFILE_ID, dataForPrimaryUser) 1106 val dataForWork = safetySourceTestData.informationWithIssueForWork 1107 val managedSafetyCenterManager = 1108 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 1109 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1110 SINGLE_SOURCE_ALL_PROFILE_ID, 1111 dataForWork 1112 ) 1113 1114 val apiSafetySourceData = 1115 safetyCenterManager.getSafetySourceDataWithPermission(SINGLE_SOURCE_ALL_PROFILE_ID) 1116 val apiSafetySourceDataForWork = 1117 managedSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1118 SINGLE_SOURCE_ALL_PROFILE_ID 1119 ) 1120 assertThat(apiSafetySourceData).isEqualTo(dataForPrimaryUser) 1121 assertThat(apiSafetySourceDataForWork).isEqualTo(dataForWork) 1122 } 1123 1124 @Test 1125 @Postsubmit(reason = "Test takes too much time to setup") 1126 @EnsureHasAdditionalUser(installInstrumentedApp = TRUE) setSafetySourceData_forStoppedUser_shouldSetDatanull1127 fun setSafetySourceData_forStoppedUser_shouldSetData() { 1128 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceConfig) 1129 deviceState.additionalUser().stop() 1130 1131 val dataForPrimaryUser = safetySourceTestData.unspecified 1132 val additionalUserSafetyCenterManager = 1133 getSafetyCenterManagerForUser(deviceState.additionalUser().userHandle()) 1134 additionalUserSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1135 SINGLE_SOURCE_ID, 1136 dataForPrimaryUser 1137 ) 1138 1139 val apiSafetySourceData = 1140 additionalUserSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1141 SINGLE_SOURCE_ID 1142 ) 1143 assertThat(apiSafetySourceData).isEqualTo(dataForPrimaryUser) 1144 } 1145 1146 @Test 1147 @Postsubmit(reason = "Test takes too much time to setup") 1148 @EnsureHasAdditionalUser(installInstrumentedApp = TRUE) setSafetySourceData_forBothPrimaryAdditionalUser_shouldSetDatanull1149 fun setSafetySourceData_forBothPrimaryAdditionalUser_shouldSetData() { 1150 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceConfig) 1151 1152 val dataForPrimaryUser = safetySourceTestData.information 1153 safetyCenterTestHelper.setData(SINGLE_SOURCE_ID, dataForPrimaryUser) 1154 val dataForAdditionalUser = safetySourceTestData.unspecified 1155 val additionalUserSafetyCenterManager = 1156 getSafetyCenterManagerForUser(deviceState.additionalUser().userHandle()) 1157 additionalUserSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1158 SINGLE_SOURCE_ID, 1159 dataForAdditionalUser 1160 ) 1161 1162 val apiSafetySourceDataForPrimaryUser = 1163 safetyCenterManager.getSafetySourceDataWithPermission(SINGLE_SOURCE_ID) 1164 val apiSafetySourceDataForAdditionalUser = 1165 additionalUserSafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1166 SINGLE_SOURCE_ID 1167 ) 1168 assertThat(apiSafetySourceDataForPrimaryUser).isEqualTo(dataForPrimaryUser) 1169 assertThat(apiSafetySourceDataForAdditionalUser).isEqualTo(dataForAdditionalUser) 1170 } 1171 1172 @Test 1173 @Postsubmit(reason = "Test takes too much time to setup") 1174 @EnsureHasAdditionalUser(installInstrumentedApp = TRUE) setSafetySourceData_forAdditionalUser_shouldNotAffectDataForPrimaryUsernull1175 fun setSafetySourceData_forAdditionalUser_shouldNotAffectDataForPrimaryUser() { 1176 safetyCenterTestHelper.setConfig(safetyCenterTestConfigs.singleSourceConfig) 1177 1178 val dataForAdditionalUser = safetySourceTestData.unspecified 1179 val additionalUserSafetyCenterManager = 1180 getSafetyCenterManagerForUser(deviceState.additionalUser().userHandle()) 1181 additionalUserSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1182 SINGLE_SOURCE_ID, 1183 dataForAdditionalUser 1184 ) 1185 1186 val apiSafetySourceDataForPrimaryUser = 1187 safetyCenterManager.getSafetySourceDataWithPermission(SINGLE_SOURCE_ID) 1188 assertThat(apiSafetySourceDataForPrimaryUser).isEqualTo(null) 1189 } 1190 findWorkPolicyInfonull1191 private fun findWorkPolicyInfo() { 1192 context.launchSafetyCenterActivity { 1193 // TODO(b/233188021): This needs to use the Enterprise API to override the "work" 1194 // keyword. 1195 waitAllTextDisplayed("Your work policy info", "Settings managed by your IT admin") 1196 } 1197 } 1198 getSafetyCenterManagerForUsernull1199 private fun getSafetyCenterManagerForUser(userHandle: UserHandle): SafetyCenterManager { 1200 val contextForUser = getContextForUser(userHandle) 1201 return contextForUser.getSystemService(SafetyCenterManager::class.java)!! 1202 } 1203 getContextForUsernull1204 private fun getContextForUser(userHandle: UserHandle): Context { 1205 return callWithShellPermissionIdentity(INTERACT_ACROSS_USERS_FULL) { 1206 context.createContextAsUser(userHandle, 0) 1207 } 1208 } 1209 createTestActivityRedirectPendingIntentForUsernull1210 private fun createTestActivityRedirectPendingIntentForUser(user: UserHandle): PendingIntent { 1211 return callWithShellPermissionIdentity(INTERACT_ACROSS_USERS) { 1212 SafetySourceTestData.createRedirectPendingIntent( 1213 getContextForUser(user), 1214 Intent(ACTION_TEST_ACTIVITY) 1215 ) 1216 } 1217 } 1218 SafetyCenterManagernull1219 private fun SafetyCenterManager.getSafetySourceDataWithInteractAcrossUsersPermission( 1220 id: String 1221 ): SafetySourceData? = 1222 callWithShellPermissionIdentity(INTERACT_ACROSS_USERS_FULL) { 1223 getSafetySourceDataWithPermission(id) 1224 } 1225 SafetyCenterManagernull1226 private fun SafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1227 id: String, 1228 dataToSet: SafetySourceData, 1229 safetyEvent: SafetyEvent = EVENT_SOURCE_STATE_CHANGED 1230 ) = 1231 callWithShellPermissionIdentity(INTERACT_ACROSS_USERS_FULL) { 1232 setSafetySourceDataWithPermission(id, dataToSet, safetyEvent) 1233 } 1234 SafetyCenterManagernull1235 private fun SafetyCenterManager.getSafetyCenterDataWithInteractAcrossUsersPermission(): 1236 SafetyCenterData = 1237 callWithShellPermissionIdentity(INTERACT_ACROSS_USERS_FULL) { 1238 getSafetyCenterDataWithPermission() 1239 } 1240 setQuietModenull1241 private fun setQuietMode(value: Boolean) { 1242 deviceState.workProfile().setQuietMode(value) 1243 inQuietMode = value 1244 } 1245 resetQuietModenull1246 private fun resetQuietMode() { 1247 if (!inQuietMode) { 1248 return 1249 } 1250 setQuietMode(false) 1251 } 1252 safetyCenterEntryOkForWorknull1253 private fun safetyCenterEntryOkForWork(sourceId: String, managedUserId: Int) = 1254 safetyCenterTestData 1255 .safetyCenterEntryOkBuilder(sourceId, managedUserId, title = "Ok title for Work") 1256 .build() 1257 1258 private fun updatePrimaryProfileSources() { 1259 safetyCenterTestHelper.setData( 1260 DYNAMIC_BAREBONE_ID, 1261 safetySourceTestData.criticalWithResolvingGeneralIssue 1262 ) 1263 safetyCenterTestHelper.setData( 1264 DYNAMIC_DISABLED_ID, 1265 safetySourceTestData.recommendationWithGeneralIssue 1266 ) 1267 safetyCenterTestHelper.setData(DYNAMIC_HIDDEN_ID, safetySourceTestData.unspecified) 1268 safetyCenterTestHelper.setData( 1269 ISSUE_ONLY_BAREBONE_ID, 1270 SafetySourceTestData.issuesOnly(safetySourceTestData.criticalResolvingGeneralIssue) 1271 ) 1272 safetyCenterTestHelper.setData( 1273 ISSUE_ONLY_ALL_OPTIONAL_ID, 1274 SafetySourceTestData.issuesOnly(safetySourceTestData.recommendationGeneralIssue) 1275 ) 1276 safetyCenterTestHelper.setData( 1277 DYNAMIC_IN_STATELESS_ID, 1278 safetySourceTestData.unspecifiedWithIssue 1279 ) 1280 safetyCenterTestHelper.setData( 1281 ISSUE_ONLY_IN_STATELESS_ID, 1282 SafetySourceTestData.issuesOnly(safetySourceTestData.informationIssue) 1283 ) 1284 } 1285 updateWorkProfileSourcesnull1286 private fun updateWorkProfileSources() { 1287 val managedSafetyCenterManager = 1288 getSafetyCenterManagerForUser(deviceState.workProfile().userHandle()) 1289 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1290 DYNAMIC_DISABLED_ID, 1291 safetySourceTestData.informationWithIssueForWork 1292 ) 1293 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1294 DYNAMIC_HIDDEN_ID, 1295 safetySourceTestData.informationWithIssueForWork 1296 ) 1297 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1298 ISSUE_ONLY_ALL_OPTIONAL_ID, 1299 SafetySourceTestData.issuesOnly(safetySourceTestData.informationIssue) 1300 ) 1301 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1302 DYNAMIC_IN_STATELESS_ID, 1303 safetySourceTestData.unspecifiedWithIssueForWork 1304 ) 1305 managedSafetyCenterManager.setSafetySourceDataWithInteractAcrossUsersPermission( 1306 ISSUE_ONLY_IN_STATELESS_ID, 1307 SafetySourceTestData.issuesOnly(safetySourceTestData.informationIssue) 1308 ) 1309 } 1310 } 1311