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