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 com.android.settings.safetycenter; 18 19 import static android.safetycenter.SafetyEvent.SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED; 20 21 import static com.google.common.truth.Truth.assertThat; 22 23 import static org.mockito.ArgumentMatchers.any; 24 import static org.mockito.ArgumentMatchers.anyInt; 25 import static org.mockito.ArgumentMatchers.eq; 26 import static org.mockito.Mockito.never; 27 import static org.mockito.Mockito.verify; 28 import static org.mockito.Mockito.when; 29 30 import android.content.Context; 31 import android.content.Intent; 32 import android.platform.test.annotations.RequiresFlagsDisabled; 33 import android.platform.test.annotations.RequiresFlagsEnabled; 34 import android.platform.test.flag.junit.CheckFlagsRule; 35 import android.platform.test.flag.junit.DeviceFlagsValueProvider; 36 import android.safetycenter.SafetyEvent; 37 import android.safetycenter.SafetySourceData; 38 import android.safetycenter.SafetySourceIssue; 39 import android.safetycenter.SafetySourceStatus; 40 import android.safetycenter.SafetySourceStatus.IconAction; 41 42 import androidx.test.core.app.ApplicationProvider; 43 import androidx.test.ext.junit.runners.AndroidJUnit4; 44 45 import com.android.internal.widget.LockPatternUtils; 46 import com.android.settings.flags.Flags; 47 import com.android.settings.security.ScreenLockPreferenceDetailsUtils; 48 import com.android.settings.testutils.FakeFeatureFactory; 49 import com.android.settings.testutils.ResourcesUtils; 50 51 import org.junit.After; 52 import org.junit.Before; 53 import org.junit.Rule; 54 import org.junit.Test; 55 import org.junit.runner.RunWith; 56 import org.mockito.ArgumentCaptor; 57 import org.mockito.Mock; 58 import org.mockito.MockitoAnnotations; 59 60 @RunWith(AndroidJUnit4.class) 61 public class LockScreenSafetySourceTest { 62 63 private static final String SUMMARY = "summary"; 64 private static final String FAKE_ACTION_OPEN_SUB_SETTING = "open_sub_setting"; 65 private static final String EXTRA_DESTINATION = "destination"; 66 private static final String FAKE_CHOOSE_LOCK_GENERIC_FRAGMENT = "choose_lock_generic"; 67 private static final String FAKE_SCREEN_LOCK_SETTINGS = "screen_lock_settings"; 68 private static final SafetyEvent EVENT_SOURCE_STATE_CHANGED = 69 new SafetyEvent.Builder(SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED).build(); 70 71 @Rule 72 public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); 73 74 private Context mApplicationContext; 75 76 @Mock private SafetyCenterManagerWrapper mSafetyCenterManagerWrapper; 77 78 @Mock private ScreenLockPreferenceDetailsUtils mScreenLockPreferenceDetailsUtils; 79 80 @Mock private LockPatternUtils mLockPatternUtils; 81 82 @Before setUp()83 public void setUp() { 84 MockitoAnnotations.initMocks(this); 85 mApplicationContext = ApplicationProvider.getApplicationContext(); 86 SafetyCenterManagerWrapper.sInstance = mSafetyCenterManagerWrapper; 87 final FakeFeatureFactory featureFactory = FakeFeatureFactory.setupForTest(); 88 when(featureFactory.securityFeatureProvider.getLockPatternUtils(mApplicationContext)) 89 .thenReturn(mLockPatternUtils); 90 } 91 92 @After tearDown()93 public void tearDown() { 94 SafetyCenterManagerWrapper.sInstance = null; 95 } 96 97 @Test setSafetySourceData_whenScreenLockEnabled_safetyCenterDisabled_doesNotSetData()98 public void setSafetySourceData_whenScreenLockEnabled_safetyCenterDisabled_doesNotSetData() { 99 whenScreenLockIsEnabled(); 100 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(false); 101 when(mScreenLockPreferenceDetailsUtils.isAvailable()).thenReturn(true); 102 103 LockScreenSafetySource.setSafetySourceData( 104 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 105 106 verify(mSafetyCenterManagerWrapper, never()) 107 .setSafetySourceData(any(), any(), any(), any()); 108 } 109 110 @Test setSafetySourceData_whenScreenLockIsDisabled_setsNullData()111 public void setSafetySourceData_whenScreenLockIsDisabled_setsNullData() { 112 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 113 when(mScreenLockPreferenceDetailsUtils.isAvailable()).thenReturn(false); 114 115 LockScreenSafetySource.setSafetySourceData( 116 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 117 118 verify(mSafetyCenterManagerWrapper) 119 .setSafetySourceData( 120 any(), eq(LockScreenSafetySource.SAFETY_SOURCE_ID), eq(null), any()); 121 } 122 123 @Test setSafetySourceData_setsDataForLockscreenSafetySource()124 public void setSafetySourceData_setsDataForLockscreenSafetySource() { 125 whenScreenLockIsEnabled(); 126 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 127 128 LockScreenSafetySource.setSafetySourceData( 129 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 130 131 verify(mSafetyCenterManagerWrapper) 132 .setSafetySourceData( 133 any(), eq(LockScreenSafetySource.SAFETY_SOURCE_ID), any(), any()); 134 } 135 136 @Test setSafetySourceData_setsDataWithCorrectSafetyEvent()137 public void setSafetySourceData_setsDataWithCorrectSafetyEvent() { 138 whenScreenLockIsEnabled(); 139 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 140 141 LockScreenSafetySource.setSafetySourceData( 142 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 143 144 verify(mSafetyCenterManagerWrapper) 145 .setSafetySourceData(any(), any(), any(), eq(EVENT_SOURCE_STATE_CHANGED)); 146 } 147 148 @Test setSafetySourceData_whenScreenLockIsEnabled_setData()149 public void setSafetySourceData_whenScreenLockIsEnabled_setData() { 150 whenScreenLockIsEnabled(); 151 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 152 153 LockScreenSafetySource.setSafetySourceData( 154 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 155 156 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 157 verify(mSafetyCenterManagerWrapper) 158 .setSafetySourceData(any(), any(), captor.capture(), any()); 159 SafetySourceData safetySourceData = captor.getValue(); 160 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 161 162 assertThat(safetySourceStatus.getTitle().toString()) 163 .isEqualTo( 164 ResourcesUtils.getResourcesString( 165 mApplicationContext, "unlock_set_unlock_launch_picker_title")); 166 assertThat(safetySourceStatus.getSummary().toString()).isEqualTo(SUMMARY); 167 assertThat(safetySourceStatus.getPendingIntent().getIntent()).isNotNull(); 168 assertThat(safetySourceStatus.getPendingIntent().getIntent().getAction()) 169 .isEqualTo(FAKE_ACTION_OPEN_SUB_SETTING); 170 assertThat( 171 safetySourceStatus 172 .getPendingIntent() 173 .getIntent() 174 .getStringExtra(EXTRA_DESTINATION)) 175 .isEqualTo(FAKE_CHOOSE_LOCK_GENERIC_FRAGMENT); 176 } 177 178 @Test setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsSec_setStatusLevelInfo()179 public void setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsSec_setStatusLevelInfo() { 180 whenScreenLockIsEnabled(); 181 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 182 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(true); 183 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 184 .thenReturn(false); 185 186 LockScreenSafetySource.setSafetySourceData( 187 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 188 189 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 190 verify(mSafetyCenterManagerWrapper) 191 .setSafetySourceData( 192 any(), 193 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 194 captor.capture(), 195 any()); 196 SafetySourceData safetySourceData = captor.getValue(); 197 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 198 199 assertThat(safetySourceStatus.getSeverityLevel()) 200 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_INFORMATION); 201 } 202 203 @Test setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsNotSec_setStatusLevelRec()204 public void setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsNotSec_setStatusLevelRec() { 205 whenScreenLockIsEnabled(); 206 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 207 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(false); 208 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 209 .thenReturn(false); 210 211 LockScreenSafetySource.setSafetySourceData( 212 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 213 214 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 215 verify(mSafetyCenterManagerWrapper) 216 .setSafetySourceData( 217 any(), 218 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 219 captor.capture(), 220 any()); 221 SafetySourceData safetySourceData = captor.getValue(); 222 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 223 224 assertThat(safetySourceStatus.getSeverityLevel()) 225 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_RECOMMENDATION); 226 } 227 228 @Test setSafetySourceData_whenPwdQualIsMan_whenLockPattIsSec_setStatusLevelUnsp()229 public void setSafetySourceData_whenPwdQualIsMan_whenLockPattIsSec_setStatusLevelUnsp() { 230 whenScreenLockIsEnabled(); 231 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 232 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(true); 233 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 234 .thenReturn(true); 235 236 LockScreenSafetySource.setSafetySourceData( 237 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 238 239 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 240 verify(mSafetyCenterManagerWrapper) 241 .setSafetySourceData( 242 any(), 243 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 244 captor.capture(), 245 any()); 246 SafetySourceData safetySourceData = captor.getValue(); 247 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 248 249 assertThat(safetySourceStatus.getSeverityLevel()) 250 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_UNSPECIFIED); 251 } 252 253 @Test setSafetySourceData_whenPwdQualIsMan_whenLockPattIsNotSec_setStatusLevelUnsp()254 public void setSafetySourceData_whenPwdQualIsMan_whenLockPattIsNotSec_setStatusLevelUnsp() { 255 whenScreenLockIsEnabled(); 256 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 257 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(false); 258 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 259 .thenReturn(true); 260 261 LockScreenSafetySource.setSafetySourceData( 262 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 263 264 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 265 verify(mSafetyCenterManagerWrapper) 266 .setSafetySourceData( 267 any(), 268 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 269 captor.capture(), 270 any()); 271 SafetySourceData safetySourceData = captor.getValue(); 272 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 273 274 assertThat(safetySourceStatus.getSeverityLevel()) 275 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_UNSPECIFIED); 276 } 277 278 @Test setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsSec_doesNotSetIssues()279 public void setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsSec_doesNotSetIssues() { 280 whenScreenLockIsEnabled(); 281 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 282 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(true); 283 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 284 .thenReturn(false); 285 286 LockScreenSafetySource.setSafetySourceData( 287 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 288 289 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 290 verify(mSafetyCenterManagerWrapper) 291 .setSafetySourceData(any(), any(), captor.capture(), any()); 292 SafetySourceData safetySourceData = captor.getValue(); 293 294 assertThat(safetySourceData.getIssues()).isEmpty(); 295 } 296 297 @Test setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsNotSec_setsIssue()298 public void setSafetySourceData_whenPwdQualIsNotMan_whenLockPattIsNotSec_setsIssue() { 299 whenScreenLockIsEnabled(); 300 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 301 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(false); 302 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 303 .thenReturn(false); 304 305 LockScreenSafetySource.setSafetySourceData( 306 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 307 308 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 309 verify(mSafetyCenterManagerWrapper) 310 .setSafetySourceData( 311 any(), 312 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 313 captor.capture(), 314 any()); 315 SafetySourceData safetySourceData = captor.getValue(); 316 317 assertThat(safetySourceData.getIssues()).hasSize(1); 318 SafetySourceIssue issue = safetySourceData.getIssues().get(0); 319 assertThat(issue.getId()).isEqualTo(LockScreenSafetySource.NO_SCREEN_LOCK_ISSUE_ID); 320 assertThat(issue.getTitle().toString()) 321 .isEqualTo( 322 ResourcesUtils.getResourcesString( 323 mApplicationContext, "no_screen_lock_issue_title")); 324 assertThat(issue.getSummary().toString()) 325 .isEqualTo( 326 ResourcesUtils.getResourcesString( 327 mApplicationContext, "no_screen_lock_issue_summary")); 328 assertThat(issue.getSeverityLevel()) 329 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_RECOMMENDATION); 330 assertThat(issue.getIssueTypeId()) 331 .isEqualTo(LockScreenSafetySource.NO_SCREEN_LOCK_ISSUE_TYPE_ID); 332 assertThat(issue.getIssueCategory()).isEqualTo(SafetySourceIssue.ISSUE_CATEGORY_DEVICE); 333 assertThat(issue.getActions()).hasSize(1); 334 SafetySourceIssue.Action action = issue.getActions().get(0); 335 assertThat(action.getId()).isEqualTo(LockScreenSafetySource.SET_SCREEN_LOCK_ACTION_ID); 336 assertThat(action.getLabel().toString()) 337 .isEqualTo( 338 ResourcesUtils.getResourcesString( 339 mApplicationContext, "no_screen_lock_issue_action_label")); 340 assertThat(action.getPendingIntent().getIntent().getAction()) 341 .isEqualTo(FAKE_ACTION_OPEN_SUB_SETTING); 342 assertThat(action.getPendingIntent().getIntent().getStringExtra(EXTRA_DESTINATION)) 343 .isEqualTo(FAKE_CHOOSE_LOCK_GENERIC_FRAGMENT); 344 } 345 346 @Test setSafetySourceData_whenPwdQualIsMan_whenLockPattIsSec_doesNotSetIssues()347 public void setSafetySourceData_whenPwdQualIsMan_whenLockPattIsSec_doesNotSetIssues() { 348 whenScreenLockIsEnabled(); 349 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 350 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(true); 351 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 352 .thenReturn(true); 353 354 LockScreenSafetySource.setSafetySourceData( 355 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 356 357 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 358 verify(mSafetyCenterManagerWrapper) 359 .setSafetySourceData(any(), any(), captor.capture(), any()); 360 SafetySourceData safetySourceData = captor.getValue(); 361 362 assertThat(safetySourceData.getIssues()).isEmpty(); 363 } 364 365 @Test setSafetySourceData_whenPwdQualIsMan_whenLockPattIsNotSec_doesNotSetIssues()366 public void setSafetySourceData_whenPwdQualIsMan_whenLockPattIsNotSec_doesNotSetIssues() { 367 whenScreenLockIsEnabled(); 368 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 369 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(false); 370 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 371 .thenReturn(true); 372 373 LockScreenSafetySource.setSafetySourceData( 374 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 375 376 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 377 verify(mSafetyCenterManagerWrapper) 378 .setSafetySourceData( 379 any(), 380 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 381 captor.capture(), 382 any()); 383 SafetySourceData safetySourceData = captor.getValue(); 384 385 assertThat(safetySourceData.getIssues()).isEmpty(); 386 } 387 388 @Test setSafetySourceData_whenPasswordQualityIsManaged_setDisabled()389 public void setSafetySourceData_whenPasswordQualityIsManaged_setDisabled() { 390 whenScreenLockIsEnabled(); 391 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 392 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 393 .thenReturn(true); 394 395 LockScreenSafetySource.setSafetySourceData( 396 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 397 398 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 399 verify(mSafetyCenterManagerWrapper) 400 .setSafetySourceData( 401 any(), 402 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 403 captor.capture(), 404 any()); 405 SafetySourceData safetySourceData = captor.getValue(); 406 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 407 408 assertThat(safetySourceStatus.isEnabled()).isFalse(); 409 assertThat(safetySourceStatus.getPendingIntent()).isNull(); 410 assertThat(safetySourceStatus.getIconAction()).isNull(); 411 assertThat(safetySourceStatus.getSeverityLevel()) 412 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_UNSPECIFIED); 413 assertThat(safetySourceStatus.getSummary().toString()) 414 .isEqualTo( 415 ResourcesUtils.getResourcesString( 416 mApplicationContext, "disabled_by_policy_title")); 417 } 418 419 @Test setSafetySourceData_whenPasswordQualityIsNotManaged_setEnabled()420 public void setSafetySourceData_whenPasswordQualityIsNotManaged_setEnabled() { 421 whenScreenLockIsEnabled(); 422 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 423 when(mScreenLockPreferenceDetailsUtils.isPasswordQualityManaged(anyInt(), any())) 424 .thenReturn(false); 425 when(mScreenLockPreferenceDetailsUtils.isLockPatternSecure()).thenReturn(true); 426 when(mScreenLockPreferenceDetailsUtils.shouldShowGearMenu()).thenReturn(true); 427 428 LockScreenSafetySource.setSafetySourceData( 429 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 430 431 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 432 verify(mSafetyCenterManagerWrapper) 433 .setSafetySourceData( 434 any(), 435 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 436 captor.capture(), 437 any()); 438 SafetySourceData safetySourceData = captor.getValue(); 439 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 440 441 assertThat(safetySourceStatus.isEnabled()).isTrue(); 442 assertThat(safetySourceStatus.getPendingIntent()).isNotNull(); 443 assertThat(safetySourceStatus.getIconAction()).isNotNull(); 444 assertThat(safetySourceStatus.getSeverityLevel()) 445 .isEqualTo(SafetySourceData.SEVERITY_LEVEL_INFORMATION); 446 assertThat(safetySourceStatus.getSummary().toString()).isEqualTo(SUMMARY); 447 } 448 449 @Test setSafetySourceData_whenShouldShowGearMenu_setGearMenuActionIcon()450 public void setSafetySourceData_whenShouldShowGearMenu_setGearMenuActionIcon() { 451 whenScreenLockIsEnabled(); 452 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 453 when(mScreenLockPreferenceDetailsUtils.shouldShowGearMenu()).thenReturn(true); 454 455 LockScreenSafetySource.setSafetySourceData( 456 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 457 458 final ArgumentCaptor<SafetySourceData> captor = 459 ArgumentCaptor.forClass(SafetySourceData.class); 460 verify(mSafetyCenterManagerWrapper) 461 .setSafetySourceData( 462 any(), 463 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 464 captor.capture(), 465 any()); 466 final IconAction iconAction = captor.getValue().getStatus().getIconAction(); 467 468 assertThat(iconAction.getIconType()).isEqualTo(IconAction.ICON_TYPE_GEAR); 469 assertThat(iconAction.getPendingIntent().getIntent().getAction()) 470 .isEqualTo(FAKE_ACTION_OPEN_SUB_SETTING); 471 assertThat(iconAction.getPendingIntent().getIntent().getStringExtra(EXTRA_DESTINATION)) 472 .isEqualTo(FAKE_SCREEN_LOCK_SETTINGS); 473 } 474 475 @Test setSafetySourceData_whenShouldNotShowGearMenu_doesNotSetGearMenuActionIcon()476 public void setSafetySourceData_whenShouldNotShowGearMenu_doesNotSetGearMenuActionIcon() { 477 whenScreenLockIsEnabled(); 478 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 479 when(mScreenLockPreferenceDetailsUtils.shouldShowGearMenu()).thenReturn(false); 480 481 LockScreenSafetySource.setSafetySourceData( 482 mApplicationContext, mScreenLockPreferenceDetailsUtils, EVENT_SOURCE_STATE_CHANGED); 483 484 ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class); 485 verify(mSafetyCenterManagerWrapper) 486 .setSafetySourceData( 487 any(), 488 eq(LockScreenSafetySource.SAFETY_SOURCE_ID), 489 captor.capture(), 490 any()); 491 SafetySourceData safetySourceData = captor.getValue(); 492 SafetySourceStatus safetySourceStatus = safetySourceData.getStatus(); 493 494 assertThat(safetySourceStatus.getIconAction()).isNull(); 495 } 496 497 @Test 498 @RequiresFlagsDisabled(Flags.FLAG_BIOMETRICS_ONBOARDING_EDUCATION) 499 public void onLockScreenChange_whenSafetyCenterEnabled_flagOff_setsLockscreenAndBiometricData()500 onLockScreenChange_whenSafetyCenterEnabled_flagOff_setsLockscreenAndBiometricData() { 501 whenScreenLockIsEnabled(); 502 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 503 504 LockScreenSafetySource.onLockScreenChange(mApplicationContext); 505 506 verify(mSafetyCenterManagerWrapper) 507 .setSafetySourceData( 508 any(), eq(LockScreenSafetySource.SAFETY_SOURCE_ID), any(), any()); 509 verify(mSafetyCenterManagerWrapper) 510 .setSafetySourceData( 511 any(), eq(BiometricsSafetySource.SAFETY_SOURCE_ID), any(), any()); 512 } 513 514 @Test 515 @RequiresFlagsEnabled(Flags.FLAG_BIOMETRICS_ONBOARDING_EDUCATION) onLockScreenChange_whenSafetyCenterEnabled_flagOn_setsLockscreenAndBiometricData()516 public void onLockScreenChange_whenSafetyCenterEnabled_flagOn_setsLockscreenAndBiometricData() { 517 whenScreenLockIsEnabled(); 518 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(true); 519 520 LockScreenSafetySource.onLockScreenChange(mApplicationContext); 521 522 verify(mSafetyCenterManagerWrapper) 523 .setSafetySourceData( 524 any(), eq(LockScreenSafetySource.SAFETY_SOURCE_ID), any(), any()); 525 verify(mSafetyCenterManagerWrapper) 526 .setSafetySourceData(any(), eq(FaceSafetySource.SAFETY_SOURCE_ID), any(), any()); 527 verify(mSafetyCenterManagerWrapper) 528 .setSafetySourceData( 529 any(), eq(FingerprintSafetySource.SAFETY_SOURCE_ID), any(), any()); 530 verify(mSafetyCenterManagerWrapper) 531 .setSafetySourceData( 532 any(), eq(WearSafetySource.SAFETY_SOURCE_ID), any(), any()); 533 } 534 535 @Test onLockScreenChange_whenSafetyCenterDisabled_doesNotSetData()536 public void onLockScreenChange_whenSafetyCenterDisabled_doesNotSetData() { 537 whenScreenLockIsEnabled(); 538 when(mSafetyCenterManagerWrapper.isEnabled(mApplicationContext)).thenReturn(false); 539 540 LockScreenSafetySource.onLockScreenChange(mApplicationContext); 541 542 verify(mSafetyCenterManagerWrapper, never()) 543 .setSafetySourceData(any(), any(), any(), any()); 544 } 545 whenScreenLockIsEnabled()546 private void whenScreenLockIsEnabled() { 547 when(mScreenLockPreferenceDetailsUtils.isAvailable()).thenReturn(true); 548 when(mScreenLockPreferenceDetailsUtils.getSummary(anyInt())).thenReturn(SUMMARY); 549 550 Intent launchChooseLockGenericFragment = new Intent(FAKE_ACTION_OPEN_SUB_SETTING); 551 launchChooseLockGenericFragment.putExtra( 552 EXTRA_DESTINATION, FAKE_CHOOSE_LOCK_GENERIC_FRAGMENT); 553 when(mScreenLockPreferenceDetailsUtils.getLaunchChooseLockGenericFragmentIntent(anyInt())) 554 .thenReturn(launchChooseLockGenericFragment); 555 556 Intent launchScreenLockSettings = new Intent(FAKE_ACTION_OPEN_SUB_SETTING); 557 launchScreenLockSettings.putExtra(EXTRA_DESTINATION, FAKE_SCREEN_LOCK_SETTINGS); 558 when(mScreenLockPreferenceDetailsUtils.getLaunchScreenLockSettingsIntent(anyInt())) 559 .thenReturn(launchScreenLockSettings); 560 } 561 } 562