• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023 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.systemui.keyguard.data.repository
18 
19 import android.app.trust.TrustManager
20 import android.content.pm.UserInfo
21 import androidx.test.ext.junit.runners.AndroidJUnit4
22 import androidx.test.filters.SmallTest
23 import com.android.keyguard.logging.TrustRepositoryLogger
24 import com.android.systemui.SysuiTestCase
25 import com.android.systemui.coroutines.FlowValue
26 import com.android.systemui.coroutines.collectLastValue
27 import com.android.systemui.log.LogBuffer
28 import com.android.systemui.log.LogcatEchoTracker
29 import com.android.systemui.user.data.repository.FakeUserRepository
30 import com.android.systemui.util.mockito.whenever
31 import com.google.common.truth.Truth.assertThat
32 import kotlinx.coroutines.test.StandardTestDispatcher
33 import kotlinx.coroutines.test.TestScope
34 import kotlinx.coroutines.test.runCurrent
35 import kotlinx.coroutines.test.runTest
36 import org.junit.Before
37 import org.junit.Test
38 import org.junit.runner.RunWith
39 import org.mockito.ArgumentCaptor
40 import org.mockito.Captor
41 import org.mockito.Mock
42 import org.mockito.Mockito.mock
43 import org.mockito.Mockito.verify
44 import org.mockito.MockitoAnnotations
45 
46 @SmallTest
47 @RunWith(AndroidJUnit4::class)
48 @android.platform.test.annotations.EnabledOnRavenwood
49 class TrustRepositoryTest : SysuiTestCase() {
50     @Mock private lateinit var trustManager: TrustManager
51     @Captor private lateinit var listener: ArgumentCaptor<TrustManager.TrustListener>
52     private lateinit var userRepository: FakeUserRepository
53     private lateinit var testScope: TestScope
54     private val users = listOf(UserInfo(1, "user 1", 0), UserInfo(2, "user 1", 0))
55 
56     private lateinit var underTest: TrustRepository
57     private lateinit var isCurrentUserTrusted: FlowValue<Boolean?>
58     private lateinit var isCurrentUserTrustManaged: FlowValue<Boolean?>
59 
60     @Before
setUpnull61     fun setUp() {
62         MockitoAnnotations.initMocks(this)
63         val testDispatcher = StandardTestDispatcher()
64         testScope = TestScope(testDispatcher)
65         userRepository = FakeUserRepository()
66         userRepository.setUserInfos(users)
67         val logger =
68             TrustRepositoryLogger(
69                 LogBuffer("TestBuffer", 1, mock(LogcatEchoTracker::class.java), false)
70             )
71         underTest =
72             TrustRepositoryImpl(
73                 testScope.backgroundScope,
74                 testDispatcher,
75                 userRepository,
76                 trustManager,
77                 logger,
78             )
79     }
80 
initnull81     fun TestScope.init() {
82         runCurrent()
83         verify(trustManager).registerTrustListener(listener.capture())
84         isCurrentUserTrustManaged = collectLastValue(underTest.isCurrentUserTrustManaged)
85         isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)
86     }
87 
88     @Test
isCurrentUserTrustManaged_whenItChanges_emitsLatestValuenull89     fun isCurrentUserTrustManaged_whenItChanges_emitsLatestValue() =
90         testScope.runTest {
91             init()
92 
93             val currentUserId = users[0].id
94             userRepository.setSelectedUserInfo(users[0])
95 
96             listener.value.onTrustManagedChanged(true, currentUserId)
97             assertThat(isCurrentUserTrustManaged()).isTrue()
98 
99             listener.value.onTrustManagedChanged(false, currentUserId)
100 
101             assertThat(isCurrentUserTrustManaged()).isFalse()
102         }
103 
104     @Test
isCurrentUserTrustManaged_isFalse_byDefaultnull105     fun isCurrentUserTrustManaged_isFalse_byDefault() =
106         testScope.runTest {
107             runCurrent()
108 
109             assertThat(collectLastValue(underTest.isCurrentUserTrustManaged)()).isFalse()
110         }
111 
112     @Test
isCurrentUserTrustManaged_whenItChangesForDifferentUser_noopsnull113     fun isCurrentUserTrustManaged_whenItChangesForDifferentUser_noops() =
114         testScope.runTest {
115             init()
116             userRepository.setSelectedUserInfo(users[0])
117 
118             // current user's trust is managed.
119             listener.value.onTrustManagedChanged(true, users[0].id)
120             // some other user's trust is not managed.
121             listener.value.onTrustManagedChanged(false, users[1].id)
122 
123             assertThat(isCurrentUserTrustManaged()).isTrue()
124         }
125 
126     @Test
isCurrentUserTrustManaged_whenUserChangesWithoutRecentTrustChange_defaultsToFalsenull127     fun isCurrentUserTrustManaged_whenUserChangesWithoutRecentTrustChange_defaultsToFalse() =
128         testScope.runTest {
129             init()
130 
131             userRepository.setSelectedUserInfo(users[0])
132             listener.value.onTrustManagedChanged(true, users[0].id)
133 
134             userRepository.setSelectedUserInfo(users[1])
135 
136             assertThat(isCurrentUserTrustManaged()).isFalse()
137         }
138 
139     @Test
isCurrentUserTrustManaged_itChangesFirstBeforeUserInfoChanges_emitsCorrectValuenull140     fun isCurrentUserTrustManaged_itChangesFirstBeforeUserInfoChanges_emitsCorrectValue() =
141         testScope.runTest {
142             init()
143             userRepository.setSelectedUserInfo(users[1])
144 
145             listener.value.onTrustManagedChanged(true, users[0].id)
146             assertThat(isCurrentUserTrustManaged()).isFalse()
147 
148             userRepository.setSelectedUserInfo(users[0])
149 
150             assertThat(isCurrentUserTrustManaged()).isTrue()
151         }
152 
153     @Test
isCurrentUserTrusted_whenTrustChanges_emitsLatestValuenull154     fun isCurrentUserTrusted_whenTrustChanges_emitsLatestValue() =
155         testScope.runTest {
156             init()
157 
158             val currentUserId = users[0].id
159             userRepository.setSelectedUserInfo(users[0])
160 
161             listener.value.onTrustChanged(true, false, currentUserId, 0, emptyList())
162             assertThat(isCurrentUserTrusted()).isTrue()
163 
164             listener.value.onTrustChanged(false, false, currentUserId, 0, emptyList())
165 
166             assertThat(isCurrentUserTrusted()).isFalse()
167         }
168 
169     @Test
isCurrentUserTrusted_isFalse_byDefaultnull170     fun isCurrentUserTrusted_isFalse_byDefault() =
171         testScope.runTest {
172             runCurrent()
173 
174             val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)
175 
176             assertThat(isCurrentUserTrusted()).isFalse()
177         }
178 
179     @Test
isCurrentUserTrusted_whenTrustChangesForDifferentUser_noopnull180     fun isCurrentUserTrusted_whenTrustChangesForDifferentUser_noop() =
181         testScope.runTest {
182             init()
183 
184             userRepository.setSelectedUserInfo(users[0])
185 
186             // current user is trusted.
187             listener.value.onTrustChanged(true, true, users[0].id, 0, emptyList())
188             // some other user is not trusted.
189             listener.value.onTrustChanged(false, false, users[1].id, 0, emptyList())
190 
191             assertThat(isCurrentUserTrusted()).isTrue()
192         }
193 
194     @Test
isCurrentUserTrusted_whenTrustChangesForCurrentUser_emitsNewValuenull195     fun isCurrentUserTrusted_whenTrustChangesForCurrentUser_emitsNewValue() =
196         testScope.runTest {
197             init()
198             userRepository.setSelectedUserInfo(users[0])
199 
200             listener.value.onTrustChanged(true, true, users[0].id, 0, emptyList())
201             assertThat(isCurrentUserTrusted()).isTrue()
202 
203             listener.value.onTrustChanged(false, true, users[0].id, 0, emptyList())
204             assertThat(isCurrentUserTrusted()).isFalse()
205         }
206 
207     @Test
isCurrentUserTrusted_whenUserChangesWithoutRecentTrustChange_defaultsToFalsenull208     fun isCurrentUserTrusted_whenUserChangesWithoutRecentTrustChange_defaultsToFalse() =
209         testScope.runTest {
210             init()
211 
212             userRepository.setSelectedUserInfo(users[0])
213             listener.value.onTrustChanged(true, true, users[0].id, 0, emptyList())
214 
215             userRepository.setSelectedUserInfo(users[1])
216 
217             assertThat(isCurrentUserTrusted()).isFalse()
218         }
219 
220     @Test
isCurrentUserTrusted_trustChangesFirstBeforeUserInfoChanges_emitsCorrectValuenull221     fun isCurrentUserTrusted_trustChangesFirstBeforeUserInfoChanges_emitsCorrectValue() =
222         testScope.runTest {
223             init()
224 
225             listener.value.onTrustChanged(true, true, users[0].id, 0, emptyList())
226             assertThat(isCurrentUserTrusted()).isFalse()
227 
228             userRepository.setSelectedUserInfo(users[0])
229 
230             assertThat(isCurrentUserTrusted()).isTrue()
231         }
232 
233     @Test
isCurrentUserActiveUnlockRunning_runningFirstBeforeUserInfoChanges_emitsCorrectValuenull234     fun isCurrentUserActiveUnlockRunning_runningFirstBeforeUserInfoChanges_emitsCorrectValue() =
235         testScope.runTest {
236             runCurrent()
237             verify(trustManager).registerTrustListener(listener.capture())
238             val isCurrentUserActiveUnlockRunning by
239                 collectLastValue(underTest.isCurrentUserActiveUnlockRunning)
240             userRepository.setSelectedUserInfo(users[1])
241 
242             // active unlock running = true for users[0].id, but not the current user
243             listener.value.onIsActiveUnlockRunningChanged(true, users[0].id)
244             assertThat(isCurrentUserActiveUnlockRunning).isFalse()
245 
246             // current user is now users[0].id
247             userRepository.setSelectedUserInfo(users[0])
248             assertThat(isCurrentUserActiveUnlockRunning).isTrue()
249         }
250 
251     @Test
isCurrentUserActiveUnlockRunning_whenActiveUnlockRunningForCurrentUser_emitsNewValuenull252     fun isCurrentUserActiveUnlockRunning_whenActiveUnlockRunningForCurrentUser_emitsNewValue() =
253         testScope.runTest {
254             runCurrent()
255             verify(trustManager).registerTrustListener(listener.capture())
256             val isCurrentUserActiveUnlockRunning by
257                 collectLastValue(underTest.isCurrentUserActiveUnlockRunning)
258             userRepository.setSelectedUserInfo(users[0])
259 
260             listener.value.onIsActiveUnlockRunningChanged(true, users[0].id)
261             assertThat(isCurrentUserActiveUnlockRunning).isTrue()
262 
263             listener.value.onIsActiveUnlockRunningChanged(false, users[0].id)
264             assertThat(isCurrentUserActiveUnlockRunning).isFalse()
265 
266             listener.value.onIsActiveUnlockRunningChanged(true, users[0].id)
267             assertThat(isCurrentUserActiveUnlockRunning).isTrue()
268         }
269 
270     @Test
isTrustUsuallyManaged_providesTheValueForCurrentUsernull271     fun isTrustUsuallyManaged_providesTheValueForCurrentUser() =
272         testScope.runTest {
273             runCurrent()
274             val trustUsuallyManaged by collectLastValue(underTest.isCurrentUserTrustUsuallyManaged)
275             whenever(trustManager.isTrustUsuallyManaged(users[0].id)).thenReturn(true)
276             whenever(trustManager.isTrustUsuallyManaged(users[1].id)).thenReturn(false)
277 
278             userRepository.setSelectedUserInfo(users[0])
279 
280             assertThat(trustUsuallyManaged).isTrue()
281             userRepository.setSelectedUserInfo(users[1])
282             assertThat(trustUsuallyManaged).isFalse()
283         }
284 
285     @Test
reportKeyguardShowingChangednull286     fun reportKeyguardShowingChanged() =
287         testScope.runTest {
288             underTest.reportKeyguardShowingChanged()
289             verify(trustManager).reportKeyguardShowingChanged()
290         }
291 }
292