1 /*
2 * Copyright (C) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "user_auth_service_test.h"
17
18 #include <future>
19
20 #include "iam_common_defines.h"
21 #include "iam_ptr.h"
22
23 #include "executor_messenger_service.h"
24 #include "mock_auth_event_listener.h"
25 #include "mock_context.h"
26 #include "mock_iuser_auth_interface.h"
27 #include "mock_ipc_common.h"
28 #include "mock_user_auth_callback.h"
29 #include "mock_user_auth_service.h"
30 #include "mock_resource_node.h"
31 #include "mock_widget_callback_interface.h"
32 #include "resource_node_pool.h"
33 #include "user_auth_service.h"
34
35 namespace OHOS {
36 namespace UserIam {
37 namespace UserAuth {
38 using namespace testing;
39 using namespace testing::ext;
SetUpTestCase()40 void UserAuthServiceTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void UserAuthServiceTest::TearDownTestCase()
45 {
46 }
47
SetUp()48 void UserAuthServiceTest::SetUp()
49 {
50 MockIUserAuthInterface::Holder::GetInstance().Reset();
51 }
52
TearDown()53 void UserAuthServiceTest::TearDown()
54 {
55 MockIUserAuthInterface::Holder::GetInstance().Reset();
56 }
57
58 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetEnrolledState001, TestSize.Level0)
59 {
60 UserAuthService service;
61 int32_t testApiVersion = 12;
62 AuthType testAuthType = FACE;
63 EnrolledState testEnrolledState;
64 uint16_t expectCredentialDigest = 23962;
65 uint16_t expectCredentialCount = 1;
66 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
67 EXPECT_NE(mockHdi, nullptr);
68 EXPECT_CALL(*mockHdi, GetEnrolledState(_, _, _))
69 .Times(1)
70 .WillOnce(
71 [expectCredentialDigest, expectCredentialCount](int32_t userId, int32_t authType,
__anon4ff6fdb40102(int32_t userId, int32_t authType, HdiEnrolledState &hdiEnrolledState) 72 HdiEnrolledState &hdiEnrolledState) {
73 hdiEnrolledState.credentialDigest = expectCredentialDigest;
74 hdiEnrolledState.credentialCount = expectCredentialCount;
75 return HDF_SUCCESS;
76 }
77 );
78 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
79 EXPECT_EQ(SUCCESS, service.GetEnrolledState(testApiVersion, testAuthType, testEnrolledState));
80 EXPECT_EQ(expectCredentialDigest, testEnrolledState.credentialDigest);
81 EXPECT_EQ(expectCredentialCount, testEnrolledState.credentialCount);
82 IpcCommon::DeleteAllPermission();
83 }
84
85 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetEnrolledState002, TestSize.Level0)
86 {
87 UserAuthService service;
88 int32_t testApiVersion = 12;
89 AuthType testAuthType = FACE;
90 EnrolledState testEnrolledState;
91 uint16_t expectCredentialDigest = 0;
92 uint16_t expectCredentialCount = 0;
93 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
94 EXPECT_NE(mockHdi, nullptr);
95 EXPECT_CALL(*mockHdi, GetEnrolledState(_, _, _)).WillOnce(Return(GENERAL_ERROR));
96 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
97 EXPECT_EQ(GENERAL_ERROR, service.GetEnrolledState(testApiVersion, testAuthType, testEnrolledState));
98 EXPECT_EQ(expectCredentialDigest, testEnrolledState.credentialDigest);
99 EXPECT_EQ(expectCredentialCount, testEnrolledState.credentialCount);
100 IpcCommon::DeleteAllPermission();
101 }
102
103 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetEnrolledState003, TestSize.Level0)
104 {
105 UserAuthService service;
106 int32_t testApiVersion = 10;
107 AuthType testAuthType = FACE;
108 EnrolledState testEnrolledState;
109 uint16_t expectCredentialDigest = 0;
110 uint16_t expectCredentialCount = 0;
111 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
112 EXPECT_EQ(TYPE_NOT_SUPPORT, service.GetEnrolledState(testApiVersion, testAuthType, testEnrolledState));
113 EXPECT_EQ(expectCredentialDigest, testEnrolledState.credentialDigest);
114 EXPECT_EQ(expectCredentialCount, testEnrolledState.credentialCount);
115 IpcCommon::DeleteAllPermission();
116 }
117
118 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetEnrolledState004, TestSize.Level0)
119 {
120 UserAuthService service;
121 int32_t testApiVersion = 10;
122 AuthType testAuthType = FACE;
123 EnrolledState testEnrolledState;
124 uint16_t expectCredentialDigest = 0;
125 uint16_t expectCredentialCount = 0;
126 EXPECT_EQ(CHECK_PERMISSION_FAILED, service.GetEnrolledState(testApiVersion, testAuthType, testEnrolledState));
127 EXPECT_EQ(expectCredentialDigest, testEnrolledState.credentialDigest);
128 EXPECT_EQ(expectCredentialCount, testEnrolledState.credentialCount);
129 }
130
131 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetAvailableStatus001, TestSize.Level0)
132 {
133 UserAuthService service;
134 int32_t testApiVersion = 10000;
135 AuthType testAuthType = FACE;
136 AuthTrustLevel testAuthTrustLevel = ATL3;
137 int32_t testUserId = 100;
138 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
139 EXPECT_NE(mockHdi, nullptr);
140 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _))
141 .Times(1)
142 .WillOnce(
__anon4ff6fdb40202(int32_t userId, int32_t authType, uint32_t authTrustLevel, int32_t &checkRet) 143 [](int32_t userId, int32_t authType, uint32_t authTrustLevel, int32_t &checkRet) {
144 checkRet = SUCCESS;
145 return HDF_SUCCESS;
146 }
147 );
148 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
149 EXPECT_EQ(SUCCESS, service.GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel));
150 IpcCommon::DeleteAllPermission();
151 }
152
153 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetAvailableStatus002, TestSize.Level0)
154 {
155 UserAuthService service;
156 int32_t testApiVersion = 10000;
157 AuthType testAuthType = FACE;
158 int32_t testUserId = 100;
159 AuthTrustLevel testAuthTrustLevel = static_cast<AuthTrustLevel>(90000);
160
161 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
162 EXPECT_EQ(TRUST_LEVEL_NOT_SUPPORT, service.GetAvailableStatus(testApiVersion, testUserId, testAuthType,
163 testAuthTrustLevel));
164
165 testAuthTrustLevel = ATL2;
166 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
167 EXPECT_NE(mockHdi, nullptr);
168 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(1);
169 ON_CALL(*mockHdi, GetAvailableStatus)
170 .WillByDefault(
__anon4ff6fdb40302(int32_t userId, int32_t authType, uint32_t authTrustLevel, int32_t &checkRet) 171 [](int32_t userId, int32_t authType, uint32_t authTrustLevel, int32_t &checkRet) {
172 checkRet = TRUST_LEVEL_NOT_SUPPORT;
173 return SUCCESS;
174 }
175 );
176 EXPECT_EQ(TRUST_LEVEL_NOT_SUPPORT, service.GetAvailableStatus(testApiVersion, testUserId, testAuthType,
177 testAuthTrustLevel));
178 IpcCommon::DeleteAllPermission();
179 }
180
181 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetAvailableStatus003, TestSize.Level0)
182 {
183 UserAuthService service;
184 int32_t testApiVersion = 10000;
185 AuthType testAuthType = FACE;
186 AuthTrustLevel testAuthTrustLevel = ATL2;
187 int32_t testUserId = 100;
188
189 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
190 EXPECT_NE(mockHdi, nullptr);
__anon4ff6fdb40402() 191 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).WillRepeatedly([]() {
192 return HDF_FAILURE;
193 });
194 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
195 EXPECT_EQ(GENERAL_ERROR, service.GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel));
196
197 EXPECT_EQ(GENERAL_ERROR, service.GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel));
198
199 testApiVersion = 9;
200 EXPECT_EQ(GENERAL_ERROR, service.GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel));
201 IpcCommon::DeleteAllPermission();
202 }
203
204 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetAvailableStatus004, TestSize.Level0)
205 {
206 int32_t testApiVersion = 10000;
207 AuthType testAuthType = PIN;
208 AuthTrustLevel testAuthTrustLevel = ATL2;
209 int32_t testUserId = 100;
210
211 auto service = Common::MakeShared<UserAuthService>();
212 EXPECT_NE(service, nullptr);
213 int32_t ret = service->GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel);
214 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
215
216 ret = service->GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel);
217 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
218
219 testAuthType = FACE;
220 ret = service->GetAvailableStatus(testUserId, testApiVersion, testAuthType, testAuthTrustLevel);
221 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
222
223 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
224 testAuthTrustLevel = static_cast<AuthTrustLevel>(0);
225 ret = service->GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel);
226 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
227
228 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
229 testAuthTrustLevel = static_cast<AuthTrustLevel>(0);
230 ret = service->GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel);
231 EXPECT_EQ(ret, TRUST_LEVEL_NOT_SUPPORT);
232 IpcCommon::DeleteAllPermission();
233 }
234
235 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetAvailableStatus005, TestSize.Level0)
236 {
237 int32_t testApiVersion = 10000;
238 AuthType testAuthType = PIN;
239 AuthTrustLevel testAuthTrustLevel = ATL2;
240
241 auto service = Common::MakeShared<UserAuthService>();
242 EXPECT_NE(service, nullptr);
243 int32_t ret = service->GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel);
244 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
245
246 ret = service->GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel);
247 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
248
249 testAuthType = FACE;
250 ret = service->GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel);
251 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
252
253 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
254 testAuthTrustLevel = static_cast<AuthTrustLevel>(0);
255 ret = service->GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel);
256 EXPECT_EQ(ret, TRUST_LEVEL_NOT_SUPPORT);
257 IpcCommon::DeleteAllPermission();
258 }
259
260 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetProperty001, TestSize.Level0)
261 {
262 UserAuthService service;
263 int32_t testUserId = 123;
264 AuthType testAuthType = PIN;
265 std::vector<Attributes::AttributeKey> testKeys = {Attributes::ATTR_PIN_SUB_TYPE, Attributes::ATTR_SIGNATURE};
266 sptr<MockGetExecutorPropertyCallback> testCallback(new (std::nothrow) MockGetExecutorPropertyCallback());
267 EXPECT_NE(testCallback, nullptr);
268 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
269 EXPECT_NE(mockHdi, nullptr);
270 EXPECT_CALL(*mockHdi, GetCredential(_, _, _)).Times(1);
271 EXPECT_CALL(*testCallback, OnGetExecutorPropertyResult(_, _)).Times(2);
272 sptr<GetExecutorPropertyCallbackInterface> callbackInterface = testCallback;
273 service.GetProperty(testUserId, testAuthType, testKeys, callbackInterface);
274 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
275 service.GetProperty(testUserId, testAuthType, testKeys, callbackInterface);
276 IpcCommon::DeleteAllPermission();
277 }
278
279 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetProperty002, TestSize.Level0)
280 {
281 UserAuthService service;
282 int32_t testUserId = 123;
283 AuthType testAuthType = PIN;
284 std::vector<Attributes::AttributeKey> testKeys = {Attributes::ATTR_PIN_SUB_TYPE, Attributes::ATTR_SIGNATURE};
285 sptr<MockGetExecutorPropertyCallback> testCallback(nullptr);
286 sptr<GetExecutorPropertyCallbackInterface> callbackInterface = testCallback;
287 service.GetProperty(testUserId, testAuthType, testKeys, callbackInterface);
288
289 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
290 EXPECT_NE(mockHdi, nullptr);
291 EXPECT_CALL(*mockHdi, GetCredential(_, _, _)).Times(2);
292 ON_CALL(*mockHdi, GetCredential)
293 .WillByDefault(
__anon4ff6fdb40502(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 294 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
295 HdiCredentialInfo tempInfo = {
296 .credentialId = 1,
297 .executorIndex = 2,
298 .templateId = 3,
299 .authType = static_cast<HdiAuthType>(1),
300 .executorMatcher = 2,
301 .executorSensorHint = 3,
302 };
303 infos.push_back(tempInfo);
304 return HDF_SUCCESS;
305 }
306 );
307 auto resourceNode = MockResourceNode::CreateWithExecuteIndex(2);
308 EXPECT_NE(resourceNode, nullptr);
309 EXPECT_TRUE(ResourceNodePool::Instance().Insert(resourceNode));
310 MockResourceNode *node = static_cast<MockResourceNode *>(resourceNode.get());
311 EXPECT_CALL(*node, GetProperty(_, _))
312 .Times(0)
313 .WillOnce(Return(FAIL))
314 .WillOnce(Return(SUCCESS));
315 testCallback = sptr<MockGetExecutorPropertyCallback>(new (std::nothrow) MockGetExecutorPropertyCallback());
316 EXPECT_NE(testCallback, nullptr);
317 EXPECT_CALL(*testCallback, OnGetExecutorPropertyResult(_, _)).Times(2);
318 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
319 callbackInterface = testCallback;
320 service.GetProperty(testUserId, testAuthType, testKeys, callbackInterface);
321 service.GetProperty(testUserId, testAuthType, testKeys, callbackInterface);
322 EXPECT_TRUE(ResourceNodePool::Instance().Delete(2));
323 IpcCommon::DeleteAllPermission();
324 }
325
326 HWTEST_F(UserAuthServiceTest, UserAuthServiceSetProperty001, TestSize.Level0)
327 {
328 UserAuthService service;
329 int32_t testUserId = 124;
330 AuthType testAuthType = PIN;
331 Attributes testAttr;
332 sptr<MockSetExecutorPropertyCallback> testCallback(new (std::nothrow) MockSetExecutorPropertyCallback());
333 EXPECT_NE(testCallback, nullptr);
334 EXPECT_CALL(*testCallback, OnSetExecutorPropertyResult(_)).Times(2);
335 sptr<SetExecutorPropertyCallbackInterface> callbackInterface = testCallback;
336 service.SetProperty(testUserId, testAuthType, testAttr, callbackInterface);
337 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
338 service.SetProperty(testUserId, testAuthType, testAttr, callbackInterface);
339 IpcCommon::DeleteAllPermission();
340 }
341
342 HWTEST_F(UserAuthServiceTest, UserAuthServiceSetProperty002, TestSize.Level0)
343 {
344 UserAuthService service;
345 int32_t testUserId = 124;
346 AuthType testAuthType = PIN;
347 Attributes testAttr;
348 sptr<MockSetExecutorPropertyCallback> testCallback(nullptr);
349 sptr<SetExecutorPropertyCallbackInterface> callbackInterface = testCallback;
350 service.SetProperty(testUserId, testAuthType, testAttr, callbackInterface);
351
352 auto resourceNode = MockResourceNode::CreateWithExecuteIndex(2);
353 EXPECT_NE(resourceNode, nullptr);
354 EXPECT_TRUE(ResourceNodePool::Instance().Insert(resourceNode));
355 MockResourceNode *node = static_cast<MockResourceNode *>(resourceNode.get());
356 EXPECT_CALL(*node, SetProperty(_))
357 .Times(0)
358 .WillOnce(Return(FAIL))
359 .WillOnce(Return(SUCCESS));
360 testCallback = sptr<MockSetExecutorPropertyCallback>(new (std::nothrow) MockSetExecutorPropertyCallback());
361 EXPECT_NE(testCallback, nullptr);
362 EXPECT_CALL(*testCallback, OnSetExecutorPropertyResult(_)).Times(2);
363 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
364 callbackInterface = testCallback;
365 service.SetProperty(testUserId, testAuthType, testAttr, callbackInterface);
366 service.SetProperty(testUserId, testAuthType, testAttr, callbackInterface);
367 EXPECT_TRUE(ResourceNodePool::Instance().Delete(2));
368 IpcCommon::DeleteAllPermission();
369 }
370
371 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuth001, TestSize.Level0)
372 {
373 UserAuthService service;
374 int32_t testApiVersion = 9;
375 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
376 AuthType testAuthType = FACE;
377 AuthTrustLevel testAuthTrustLevel = ATL2;
378 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
379 EXPECT_NE(testCallback, nullptr);
380 EXPECT_CALL(*testCallback, OnResult(_, _))
381 .WillOnce(
__anon4ff6fdb40602(int32_t result, const Attributes &extraInfo) 382 [](int32_t result, const Attributes &extraInfo) {
383 EXPECT_EQ(result, HDF_FAILURE);
384 }
385 );
386
387 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
388 EXPECT_NE(mockHdi, nullptr);
389 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).WillOnce(Return(HDF_FAILURE));
390
391 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
392 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
393 uint64_t contextId = service.Auth(testApiVersion, testChallenge, testAuthType,
394 testAuthTrustLevel, callbackInterface);
395 EXPECT_EQ(contextId, 0);
396 IpcCommon::DeleteAllPermission();
397 }
398
399 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuth002, TestSize.Level0)
400 {
401 UserAuthService service;
402 int32_t testApiVersion = 9;
403 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
404 AuthType testAuthType = FACE;
405 AuthTrustLevel testAuthTrustLevel = ATL2;
406 sptr<MockUserAuthCallback> testCallback(nullptr);
407 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
408 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
409 uint64_t contextId = service.Auth(testApiVersion, testChallenge, testAuthType,
410 testAuthTrustLevel, callbackInterface);
411 EXPECT_EQ(contextId, 0);
412
413 testCallback = sptr<MockUserAuthCallback>(new (std::nothrow) MockUserAuthCallback());
414 EXPECT_NE(testCallback, nullptr);
415 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(2);
416 testAuthTrustLevel = static_cast<AuthTrustLevel>(90000);
417 callbackInterface = testCallback;
418 contextId = service.Auth(testApiVersion, testChallenge, testAuthType, testAuthTrustLevel, callbackInterface);
419 EXPECT_EQ(contextId, 0);
420
421 testAuthType = PIN;
422 testAuthTrustLevel = ATL1;
423 contextId = service.Auth(testApiVersion, testChallenge, testAuthType, testAuthTrustLevel, callbackInterface);
424 EXPECT_EQ(contextId, 0);
425 IpcCommon::DeleteAllPermission();
426 }
427
428 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuth003, TestSize.Level0)
429 {
430 UserAuthService service;
431 int32_t testApiVersion = 9;
432 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
433 AuthType testAuthType = PIN;
434 AuthTrustLevel testAuthTrustLevel = ATL2;
435 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
436 EXPECT_NE(testCallback, nullptr);
437 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(4);
438
439 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
440 uint64_t contextId = service.Auth(testApiVersion, testChallenge, testAuthType,
441 testAuthTrustLevel, callbackInterface);
442 EXPECT_EQ(contextId, 0);
443
444 testAuthType = FACE;
445 contextId = service.Auth(testApiVersion, testChallenge, testAuthType, testAuthTrustLevel, callbackInterface);
446 EXPECT_EQ(contextId, 0);
447
448 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
449 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
450 EXPECT_NE(mockHdi, nullptr);
451 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(2).WillRepeatedly(Return(NOT_ENROLLED));
452 contextId = service.Auth(testApiVersion, testChallenge, testAuthType, testAuthTrustLevel, callbackInterface);
453 EXPECT_EQ(contextId, 0);
454
455 testApiVersion = 8;
456 contextId = service.Auth(testApiVersion, testChallenge, testAuthType, testAuthTrustLevel, callbackInterface);
457 EXPECT_EQ(contextId, 0);
458
459 IpcCommon::DeleteAllPermission();
460 }
461
MockForUserAuthHdi(std::shared_ptr<Context> & context,std::promise<void> & promise)462 static void MockForUserAuthHdi(std::shared_ptr<Context> &context, std::promise<void> &promise)
463 {
464 const uint32_t testScheduleId = 20;
465 const uint32_t testExecutorIndex = 60;
466 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
467 EXPECT_NE(mockHdi, nullptr);
468 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _))
469 .WillRepeatedly([&context](uint64_t contextId, const HdiAuthParam ¶m,
470 std::vector<HdiScheduleInfo> &scheduleInfos) {
471 HdiScheduleInfo scheduleInfo = {};
472 scheduleInfo.authType = HdiAuthType::FACE;
473 scheduleInfo.scheduleId = testScheduleId;
474 scheduleInfo.executorIndexes.push_back(testExecutorIndex);
475 std::vector<uint8_t> executorMessages;
476 executorMessages.resize(1);
477 scheduleInfo.executorMessages.push_back(executorMessages);
478 scheduleInfos.push_back(scheduleInfo);
479 context = ContextPool::Instance().Select(contextId).lock();
480 return HDF_SUCCESS;
481 });
482
483 EXPECT_CALL(*mockHdi, UpdateAuthenticationResult(_, _, _, _)).WillOnce(Return(HDF_SUCCESS));
484 EXPECT_CALL(*mockHdi, CancelAuthentication(_))
485 .WillOnce([&promise](uint64_t contextId) {
486 promise.set_value();
487 return HDF_SUCCESS;
488 });
489 }
490
MockForAuthResourceNode(std::shared_ptr<MockResourceNode> & resourceNode)491 static void MockForAuthResourceNode(std::shared_ptr<MockResourceNode> &resourceNode)
492 {
493 const uint32_t testScheduleId = 20;
494 const uint32_t testExecutorIndex = 60;
495 EXPECT_CALL(*resourceNode, GetExecutorIndex()).WillRepeatedly(Return(testExecutorIndex));
496 EXPECT_CALL(*resourceNode, GetAuthType()).WillRepeatedly(Return(FACE));
497 EXPECT_CALL(*resourceNode, GetExecutorRole()).WillRepeatedly(Return(ALL_IN_ONE));
498 EXPECT_CALL(*resourceNode, GetExecutorMatcher()).WillRepeatedly(Return(0));
499 EXPECT_CALL(*resourceNode, GetExecutorPublicKey()).WillRepeatedly(Return(std::vector<uint8_t>()));
500 EXPECT_CALL(*resourceNode, BeginExecute(_, _, _))
501 .WillOnce([](uint64_t scheduleId, const std::vector<uint8_t> &publicKey, const Attributes &command) {
502 auto messenger = ExecutorMessengerService::GetInstance();
503 EXPECT_NE(messenger, nullptr);
504 auto finalResult = Common::MakeShared<Attributes>();
505 EXPECT_NE(finalResult, nullptr);
506 std::vector<uint8_t> scheduleResult = {1, 2, 3, 4};
507 EXPECT_TRUE(finalResult->SetUint8ArrayValue(Attributes::ATTR_RESULT, scheduleResult));
508 EXPECT_EQ(messenger->Finish(testScheduleId, SUCCESS, finalResult), SUCCESS);
509 return SUCCESS;
510 });
511 }
512
513 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuth004, TestSize.Level0)
514 {
515 UserAuthService service;
516 int32_t testApiVersion = 9;
517 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
518 AuthType testAuthType = FACE;
519 AuthTrustLevel testAuthTrustLevel = ATL2;
520 std::shared_ptr<Context> context = nullptr;
521
522 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
523 EXPECT_NE(testCallback, nullptr);
524 EXPECT_CALL(*testCallback, OnResult(_, _))
525 .WillOnce(
__anon4ff6fdb40a02(int32_t result, const Attributes &extraInfo) 526 [&context](int32_t result, const Attributes &extraInfo) {
527 EXPECT_EQ(result, SUCCESS);
528 if (context != nullptr) {
529 context->Stop();
530 }
531 }
532 );
533
534 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
535 std::promise<void> promise;
536 MockForUserAuthHdi(context, promise);
537
538 auto resourceNode = Common::MakeShared<MockResourceNode>();
539 EXPECT_NE(resourceNode, nullptr);
540 MockForAuthResourceNode(resourceNode);
541
542 EXPECT_TRUE(ResourceNodePool::Instance().Insert(resourceNode));
543
544 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
545 service.Auth(testApiVersion, testChallenge, testAuthType, testAuthTrustLevel, callbackInterface);
546 promise.get_future().get();
547
548 EXPECT_TRUE(ResourceNodePool::Instance().Delete(60));
549 IpcCommon::DeleteAllPermission();
550 }
551
552 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthUser001, TestSize.Level0)
553 {
554 UserAuthService service;
555 AuthParamInner authParam = {
556 .userId = 125,
557 .challenge = {1, 2, 3, 4},
558 .authType = FACE,
559 .authTrustLevel = ATL2,
560 };
561 std::optional<RemoteAuthParam> remoteAuthParam = std::nullopt;
562 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
563 EXPECT_NE(testCallback, nullptr);
564 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
565 EXPECT_NE(mockHdi, nullptr);
566 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
567 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(1);
568 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
569 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
570 uint64_t contextId = service.AuthUser(authParam, remoteAuthParam, callbackInterface);
571 EXPECT_EQ(contextId, 0);
572 IpcCommon::DeleteAllPermission();
573 }
574
575 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthUser002, TestSize.Level0)
576 {
577 UserAuthService service;
578 AuthParamInner authParam = {
579 .userId = 125,
580 .challenge = {1, 2, 3, 4},
581 .authType = FACE,
582 .authTrustLevel = ATL2,
583 };
584 std::optional<RemoteAuthParam> remoteAuthParam = std::nullopt;
585 sptr<MockUserAuthCallback> testCallback(nullptr);
586 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
587 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
588 uint64_t contextId = service.AuthUser(authParam, remoteAuthParam, callbackInterface);
589 EXPECT_EQ(contextId, 0);
590
591 testCallback = sptr<MockUserAuthCallback>(new (std::nothrow) MockUserAuthCallback());
592 EXPECT_NE(testCallback, nullptr);
593 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
594 authParam.authTrustLevel = static_cast<AuthTrustLevel>(90000);
595 callbackInterface = testCallback;
596 contextId = service.AuthUser(authParam, remoteAuthParam, callbackInterface);
597 EXPECT_EQ(contextId, 0);
598 IpcCommon::DeleteAllPermission();
599 }
600
601 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthUser003, TestSize.Level0)
602 {
603 UserAuthService service;
604 AuthParamInner authParam = {
605 .userId = 125,
606 .challenge = {1, 2, 3, 4},
607 .authType = FACE,
608 .authTrustLevel = ATL2,
609 };
610 std::optional<RemoteAuthParam> remoteAuthParam = std::nullopt;
611 std::shared_ptr<Context> context = nullptr;
612
613 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
614 EXPECT_NE(testCallback, nullptr);
615 EXPECT_CALL(*testCallback, OnResult(_, _))
616 .Times(2)
617 .WillOnce(
__anon4ff6fdb40b02(int32_t result, const Attributes &extraInfo) 618 [](int32_t result, const Attributes &extraInfo) {
619 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
620 }
621 )
622 .WillOnce(
__anon4ff6fdb40c02(int32_t result, const Attributes &extraInfo) 623 [&context](int32_t result, const Attributes &extraInfo) {
624 EXPECT_EQ(result, SUCCESS);
625 if (context != nullptr) {
626 context->Stop();
627 }
628 }
629 );
630
631 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
632 uint64_t contextId = service.AuthUser(authParam, remoteAuthParam, callbackInterface);
633 EXPECT_EQ(contextId, 0);
634
635 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
636 std::promise<void> promise;
637 MockForUserAuthHdi(context, promise);
638
639 auto resourceNode = Common::MakeShared<MockResourceNode>();
640 EXPECT_NE(resourceNode, nullptr);
641 MockForAuthResourceNode(resourceNode);
642
643 EXPECT_TRUE(ResourceNodePool::Instance().Insert(resourceNode));
644
645 contextId = service.AuthUser(authParam, remoteAuthParam, callbackInterface);
646 promise.get_future().get();
647
648 EXPECT_TRUE(ResourceNodePool::Instance().Delete(60));
649 IpcCommon::DeleteAllPermission();
650 }
651
652 HWTEST_F(UserAuthServiceTest, UserAuthServiceIdentify001, TestSize.Level0)
653 {
654 UserAuthService service;
655 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
656 AuthType testAuthType = FACE;
657 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
658 EXPECT_NE(testCallback, nullptr);
659 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
660 EXPECT_NE(mockHdi, nullptr);
661 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
662 EXPECT_CALL(*mockHdi, BeginIdentification(_, _, _, _, _)).Times(1);
663 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
664 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
665 uint64_t contextId = service.Identify(testChallenge, testAuthType, callbackInterface);
666 EXPECT_EQ(contextId, 0);
667 IpcCommon::DeleteAllPermission();
668 }
669
670 HWTEST_F(UserAuthServiceTest, UserAuthServiceIdentify002, TestSize.Level0)
671 {
672 UserAuthService service;
673 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
674 AuthType testAuthType = FACE;
675 sptr<MockUserAuthCallback> testCallback(nullptr);
676 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
677 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
678 uint64_t contextId = service.Identify(testChallenge, testAuthType, callbackInterface);
679 EXPECT_EQ(contextId, 0);
680
681 testCallback = sptr<MockUserAuthCallback>(new (std::nothrow) MockUserAuthCallback());
682 EXPECT_NE(testCallback, nullptr);
683 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
684 testAuthType = PIN;
685 callbackInterface = testCallback;
686 contextId = service.Identify(testChallenge, testAuthType, callbackInterface);
687 EXPECT_EQ(contextId, 0);
688 IpcCommon::DeleteAllPermission();
689 }
690
MockForIdentifyHdi(std::shared_ptr<Context> & context,std::promise<void> & promise)691 static void MockForIdentifyHdi(std::shared_ptr<Context> &context, std::promise<void> &promise)
692 {
693 const uint32_t testExecutorIndex = 60;
694 const uint32_t testscheduleId = 20;
695 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
696 EXPECT_NE(mockHdi, nullptr);
697 EXPECT_CALL(*mockHdi, BeginIdentification(_, _, _, _, _))
698 .WillRepeatedly([&context](uint64_t contextId, int32_t authType, const std::vector<uint8_t> &challenge,
699 uint32_t executorId, HdiScheduleInfo &scheduleInfo) {
700 scheduleInfo.authType = HdiAuthType::FACE;
701 scheduleInfo.scheduleId = testscheduleId;
702 scheduleInfo.executorIndexes.push_back(testExecutorIndex);
703 std::vector<uint8_t> executorMessages;
704 executorMessages.resize(1);
705 scheduleInfo.executorMessages.push_back(executorMessages);
706 context = ContextPool::Instance().Select(contextId).lock();
707 return HDF_SUCCESS;
708 });
709
710 EXPECT_CALL(*mockHdi, UpdateIdentificationResult(_, _, _)).WillOnce(Return(HDF_SUCCESS));
711 EXPECT_CALL(*mockHdi, CancelIdentification(_))
712 .WillOnce([&promise](uint64_t contextId) {
713 promise.set_value();
714 return HDF_SUCCESS;
715 });
716 }
717
718 HWTEST_F(UserAuthServiceTest, UserAuthServiceIdentify003, TestSize.Level0)
719 {
720 UserAuthService service;
721 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
722 AuthType testAuthType = FACE;
723 std::shared_ptr<Context> context = nullptr;
724
725 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback());
726 EXPECT_NE(testCallback, nullptr);
727 EXPECT_CALL(*testCallback, OnResult(_, _))
728 .Times(2)
729 .WillOnce(
__anon4ff6fdb40f02(int32_t result, const Attributes &extraInfo) 730 [](int32_t result, const Attributes &extraInfo) {
731 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
732 }
733 )
734 .WillOnce(
__anon4ff6fdb41002(int32_t result, const Attributes &extraInfo) 735 [&context](int32_t result, const Attributes &extraInfo) {
736 EXPECT_EQ(result, SUCCESS);
737 if (context != nullptr) {
738 context->Stop();
739 }
740 }
741 );
742
743 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
744 uint64_t contextId = service.Identify(testChallenge, testAuthType, callbackInterface);
745 EXPECT_EQ(contextId, 0);
746
747 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
748 std::promise<void> promise;
749 MockForIdentifyHdi(context, promise);
750
751 auto resourceNode = Common::MakeShared<MockResourceNode>();
752 EXPECT_NE(resourceNode, nullptr);
753 MockForAuthResourceNode(resourceNode);
754
755 EXPECT_TRUE(ResourceNodePool::Instance().Insert(resourceNode));
756
757 contextId = service.Identify(testChallenge, testAuthType, callbackInterface);
758 promise.get_future().get();
759
760 EXPECT_TRUE(ResourceNodePool::Instance().Delete(60));
761 IpcCommon::DeleteAllPermission();
762 }
763
764 HWTEST_F(UserAuthServiceTest, UserAuthServiceCancelAuthOrIdentify_001, TestSize.Level0)
765 {
766 UserAuthService service;
767 uint64_t testContextId = 12355236;
768 EXPECT_EQ(service.CancelAuthOrIdentify(testContextId), CHECK_PERMISSION_FAILED);
769
770 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
771 EXPECT_EQ(service.CancelAuthOrIdentify(testContextId), GENERAL_ERROR);
772 IpcCommon::DeleteAllPermission();
773 }
774
775 HWTEST_F(UserAuthServiceTest, UserAuthServiceCancelAuthOrIdentify_002, TestSize.Level0)
776 {
777 UserAuthService service;
778 uint64_t testContextId = 0x5678;
779 uint32_t tokenId = 0x1234;
780
781 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
782 IpcCommon::SetAccessTokenId(0, true);
783 auto context = Common::MakeShared<MockContext>();
784 EXPECT_NE(context, nullptr);
785 EXPECT_CALL(*context, GetContextId()).WillRepeatedly(Return(testContextId));
786 EXPECT_CALL(*context, GetLatestError()).WillRepeatedly(Return(GENERAL_ERROR));
787 EXPECT_CALL(*context, GetTokenId()).WillRepeatedly(Return(tokenId));
788 EXPECT_CALL(*context, Stop())
789 .WillOnce(Return(false))
790 .WillRepeatedly(Return(true));
791
792 EXPECT_TRUE(ContextPool::Instance().Insert(context));
793
794 EXPECT_EQ(service.CancelAuthOrIdentify(testContextId), INVALID_CONTEXT_ID);
795 IpcCommon::SetAccessTokenId(tokenId, true);
796
797 EXPECT_EQ(service.CancelAuthOrIdentify(testContextId), GENERAL_ERROR);
798 EXPECT_EQ(service.CancelAuthOrIdentify(testContextId), SUCCESS);
799 EXPECT_TRUE(ContextPool::Instance().Delete(testContextId));
800 IpcCommon::DeleteAllPermission();
801 }
802
803 HWTEST_F(UserAuthServiceTest, UserAuthServiceGetVersion, TestSize.Level0)
804 {
805 UserAuthService service;
806 int32_t version = -1;
807 EXPECT_EQ(service.GetVersion(version), CHECK_PERMISSION_FAILED);
808 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
809 EXPECT_EQ(service.GetVersion(version), SUCCESS);
810 EXPECT_EQ(version, 1);
811 IpcCommon::DeleteAllPermission();
812 }
813
814 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_001, TestSize.Level0)
815 {
816 UserAuthService service;
817 int32_t apiVersion = 10;
818 AuthParamInner authParam;
819 authParam.challenge.push_back(1);
820 authParam.challenge.push_back(2);
821 authParam.challenge.push_back(3);
822 authParam.challenge.push_back(4);
823 authParam.authTypes.push_back(FACE);
824 authParam.authTrustLevel = ATL2;
825 WidgetParam widgetParam;
826 widgetParam.title = "使用密码验证";
827 widgetParam.navigationButtonText = "确定";
828
829 sptr<UserAuthCallbackInterface> testUserAuthCallback(nullptr);
830 EXPECT_EQ(service.AuthWidget(apiVersion, authParam, widgetParam, testUserAuthCallback), (uint64_t)0);
831 }
832
833 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_002, TestSize.Level0)
834 {
835 UserAuthService service;
836 int32_t apiVersion = 10;
837 AuthParamInner authParam;
838 authParam.challenge.push_back(1);
839 authParam.challenge.push_back(2);
840 authParam.challenge.push_back(3);
841 authParam.challenge.push_back(4);
842 authParam.authTypes.push_back(FACE);
843 authParam.authTrustLevel = ATL2;
844 WidgetParam widgetParam;
845 widgetParam.title = "使用密码验证";
846 widgetParam.navigationButtonText = "";
847 widgetParam.windowMode = WindowModeType::FULLSCREEN;
848 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
849 EXPECT_NE(testCallback, nullptr);
850 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
851 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
852 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
853 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
854 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
855 IpcCommon::DeleteAllPermission();
856 }
857
858 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_003, TestSize.Level0)
859 {
860 UserAuthService service;
861 int32_t apiVersion = 10;
862 AuthParamInner authParam;
863 authParam.challenge.push_back(1);
864 authParam.challenge.push_back(2);
865 authParam.challenge.push_back(3);
866 authParam.challenge.push_back(4);
867 authParam.authTypes.push_back(FACE);
868 authParam.authTrustLevel = ATL2;
869 WidgetParam widgetParam;
870 widgetParam.title = "使用密码验证";
871 widgetParam.navigationButtonText = "";
872 widgetParam.windowMode = WindowModeType::FULLSCREEN;
873 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
874 EXPECT_NE(testCallback, nullptr);
875 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
876 IpcCommon::AddPermission(IS_SYSTEM_APP);
877 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
878 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
879 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
880 IpcCommon::DeleteAllPermission();
881 }
882
883 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_004, TestSize.Level0)
884 {
885 UserAuthService service;
886 int32_t apiVersion = 10;
887 AuthParamInner authParam;
888 authParam.challenge.push_back(1);
889 authParam.challenge.push_back(2);
890 authParam.challenge.push_back(3);
891 authParam.challenge.push_back(4);
892 authParam.authTypes.push_back(FACE);
893 authParam.authTrustLevel = ATL2;
894 WidgetParam widgetParam;
895 widgetParam.title = "使用密码验证";
896 widgetParam.navigationButtonText = "";
897 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
898 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
899 EXPECT_NE(testCallback, nullptr);
900 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
901 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
902 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
903 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
904 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
905 IpcCommon::DeleteAllPermission();
906 }
907
908 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_005, TestSize.Level0)
909 {
910 UserAuthService service;
911 int32_t apiVersion = 10;
912 AuthParamInner authParam;
913 authParam.challenge.push_back(1);
914 authParam.challenge.push_back(2);
915 authParam.challenge.push_back(3);
916 authParam.challenge.push_back(4);
917 authParam.authTypes.push_back(FACE);
918 authParam.authTrustLevel = ATL2;
919 WidgetParam widgetParam;
920 widgetParam.title = "使用密码验证";
921 widgetParam.navigationButtonText = "";
922 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
923 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
924 EXPECT_NE(testCallback, nullptr);
925 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
926 IpcCommon::AddPermission(IS_SYSTEM_APP);
927 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
928 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
929 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
930 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
931 service.CancelAuthOrIdentify(conxtId);
932 IpcCommon::DeleteAllPermission();
933 }
934
935 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_006, TestSize.Level0)
936 {
937 UserAuthService service;
938 int32_t apiVersion = 10;
939 AuthParamInner authParam;
940 authParam.challenge.push_back(1);
941 authParam.challenge.push_back(2);
942 authParam.challenge.push_back(3);
943 authParam.challenge.push_back(4);
944 authParam.authTypes.push_back(FACE);
945 authParam.authTrustLevel = ATL2;
946 WidgetParam widgetParam;
947 widgetParam.title = "使用密码验证";
948 widgetParam.navigationButtonText = "";
949 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
950 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
951 EXPECT_NE(testCallback, nullptr);
952 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
953 IpcCommon::AddPermission(IS_SYSTEM_APP);
954 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
955 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
956 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
957 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
958 service.CancelAuthOrIdentify(conxtId);
959 IpcCommon::DeleteAllPermission();
960 }
961
962 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_007, TestSize.Level0)
963 {
964 UserAuthService service;
965 int32_t apiVersion = 10;
966 AuthParamInner authParam;
967 authParam.challenge.push_back(1);
968 authParam.challenge.push_back(2);
969 authParam.challenge.push_back(3);
970 authParam.challenge.push_back(4);
971 authParam.authTrustLevel = ATL2;
972 WidgetParam widgetParam;
973 widgetParam.title = "使用密码验证";
974 widgetParam.navigationButtonText = "";
975 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
976 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
977 EXPECT_NE(testCallback, nullptr);
978 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(2);
979 int32_t userId = 1;
980 IpcCommon::GetCallingUserId(service, userId);
981 IpcCommon::AddPermission(IS_SYSTEM_APP);
982 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
983 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
984 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
985 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
986
987 authParam.authTypes.push_back(FACE);
988 authParam.authTypes.push_back(FACE);
989 authParam.authTypes.push_back(FACE);
990 authParam.authTypes.push_back(FACE);
991 conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
992 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
993 IpcCommon::DeleteAllPermission();
994 }
995
996 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_008, TestSize.Level0)
997 {
998 UserAuthService service;
999 int32_t apiVersion = 10;
1000 AuthParamInner authParam;
1001 authParam.challenge.push_back(1);
1002 authParam.challenge.push_back(2);
1003 authParam.challenge.push_back(3);
1004 authParam.challenge.push_back(4);
1005 authParam.authTypes.push_back(static_cast<AuthType>(5));
1006 authParam.authTrustLevel = ATL2;
1007 WidgetParam widgetParam;
1008 widgetParam.title = "使用密码验证";
1009 widgetParam.navigationButtonText = "";
1010 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1011 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
1012 EXPECT_NE(testCallback, nullptr);
1013 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
1014 IpcCommon::AddPermission(IS_SYSTEM_APP);
1015 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1016 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
1017 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
1018 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1019 IpcCommon::DeleteAllPermission();
1020 }
1021
1022 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_009, TestSize.Level0)
1023 {
1024 UserAuthService service;
1025 int32_t apiVersion = 10;
1026 AuthParamInner authParam;
1027 authParam.challenge.push_back(1);
1028 authParam.challenge.push_back(2);
1029 authParam.challenge.push_back(3);
1030 authParam.challenge.push_back(4);
1031 authParam.authTypes.push_back(AuthType::ALL);
1032 authParam.authTrustLevel = ATL2;
1033 WidgetParam widgetParam;
1034 widgetParam.title = "使用密码验证";
1035 widgetParam.navigationButtonText = "";
1036 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1037 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
1038 EXPECT_NE(testCallback, nullptr);
1039 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
1040 IpcCommon::AddPermission(IS_SYSTEM_APP);
1041 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1042 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
1043 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
1044 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1045 IpcCommon::DeleteAllPermission();
1046 }
1047
1048 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_010, TestSize.Level0)
1049 {
1050 UserAuthService service;
1051 int32_t apiVersion = 10;
1052 AuthParamInner authParam;
1053 authParam.challenge.push_back(1);
1054 authParam.challenge.push_back(2);
1055 authParam.challenge.push_back(3);
1056 authParam.challenge.push_back(4);
1057 authParam.authTypes.push_back(AuthType::PIN);
1058 authParam.authTrustLevel = (AuthTrustLevel)50000;
1059 WidgetParam widgetParam;
1060 widgetParam.title = "使用密码验证";
1061 widgetParam.navigationButtonText = "";
1062 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1063 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
1064 EXPECT_NE(testCallback, nullptr);
1065 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
1066 IpcCommon::AddPermission(IS_SYSTEM_APP);
1067 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1068 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
1069 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
1070 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1071 IpcCommon::DeleteAllPermission();
1072 }
1073
1074 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_011, TestSize.Level0)
1075 {
1076 UserAuthService service;
1077 int32_t apiVersion = 10;
1078 AuthParamInner authParam;
1079 authParam.challenge.push_back(1);
1080 authParam.challenge.push_back(2);
1081 authParam.challenge.push_back(3);
1082 authParam.challenge.push_back(4);
1083 authParam.authTypes.push_back(AuthType::PIN);
1084 authParam.authTrustLevel = ATL1;
1085 WidgetParam widgetParam;
1086 widgetParam.title = "";
1087 widgetParam.navigationButtonText = "";
1088 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1089 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
1090 EXPECT_NE(testCallback, nullptr);
1091 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
1092 IpcCommon::AddPermission(IS_SYSTEM_APP);
1093 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1094 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
1095 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
1096 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1097 IpcCommon::DeleteAllPermission();
1098 }
1099
1100 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_012, TestSize.Level0)
1101 {
1102 UserAuthService service;
1103 int32_t apiVersion = 10;
1104 AuthParamInner authParam;
1105 authParam.challenge.push_back(1);
1106 authParam.challenge.push_back(2);
1107 authParam.challenge.push_back(3);
1108 authParam.challenge.push_back(4);
1109 authParam.authTypes.push_back(AuthType::PIN);
1110 authParam.authTrustLevel = ATL1;
1111 WidgetParam widgetParam;
1112 widgetParam.title = "WidgetParamTitle";
1113 widgetParam.navigationButtonText = "";
1114 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1115 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
1116 EXPECT_NE(testCallback, nullptr);
1117 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
1118 IpcCommon::AddPermission(IS_SYSTEM_APP);
1119 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1120 sptr<UserAuthCallbackInterface> callbackInterface = testCallback;
1121 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface);
1122 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1123 service.CancelAuthOrIdentify(conxtId);
1124 IpcCommon::DeleteAllPermission();
1125 }
1126
1127 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_013, TestSize.Level0)
1128 {
1129 UserAuthService service;
1130 int32_t apiVersion = 10;
1131 AuthParamInner authParam;
1132 authParam.challenge.push_back(1);
1133 authParam.challenge.push_back(2);
1134 authParam.challenge.push_back(3);
1135 authParam.challenge.push_back(4);
1136 authParam.authTypes.push_back(FACE);
1137 authParam.authTrustLevel = ATL2;
1138 WidgetParam widgetParam;
1139 widgetParam.title = "使用密码验证";
1140 widgetParam.navigationButtonText = "";
1141 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1142 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1143 EXPECT_NE(testCallback, nullptr);
1144 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1145 EXPECT_NE(tempCallback, nullptr);
1146 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1147 IpcCommon::AddPermission(IS_SYSTEM_APP);
1148 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1149 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1150 EXPECT_NE(mockHdi, nullptr);
1151 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
1152 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1153 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1154 IpcCommon::DeleteAllPermission();
1155 }
1156
1157 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_014, TestSize.Level0)
1158 {
1159 UserAuthService service;
1160 int32_t apiVersion = 10;
1161 AuthParamInner authParam;
1162 authParam.challenge.push_back(1);
1163 authParam.challenge.push_back(2);
1164 authParam.challenge.push_back(3);
1165 authParam.challenge.push_back(4);
1166 authParam.authTypes.push_back(FACE);
1167 authParam.authTrustLevel = (AuthTrustLevel)50000;
1168 WidgetParam widgetParam;
1169 widgetParam.title = "使用密码验证";
1170 widgetParam.navigationButtonText = "";
1171 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1172 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1173 EXPECT_NE(testCallback, nullptr);
1174 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1175 EXPECT_NE(tempCallback, nullptr);
1176 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1177 IpcCommon::AddPermission(IS_SYSTEM_APP);
1178 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1179 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1180 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1181 IpcCommon::DeleteAllPermission();
1182 }
1183
1184 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_015, TestSize.Level0)
1185 {
1186 UserAuthService service;
1187 int32_t apiVersion = 10;
1188 AuthParamInner authParam;
1189 authParam.challenge.push_back(1);
1190 authParam.challenge.push_back(2);
1191 authParam.challenge.push_back(3);
1192 authParam.challenge.push_back(4);
1193 authParam.authTypes.push_back(AuthType::FINGERPRINT);
1194 authParam.authTrustLevel = ATL2;
1195 WidgetParam widgetParam;
1196 widgetParam.title = "使用密码验证";
1197 widgetParam.navigationButtonText = "";
1198 widgetParam.windowMode = WindowModeType::FULLSCREEN;
1199 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1200 EXPECT_NE(testCallback, nullptr);
1201 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1202 EXPECT_NE(tempCallback, nullptr);
1203 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1204 IpcCommon::AddPermission(IS_SYSTEM_APP);
1205 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1206 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1207 EXPECT_NE(mockHdi, nullptr);
1208 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41102(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1209 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1210 HdiCredentialInfo tempInfo = {
1211 .credentialId = 1,
1212 .executorIndex = 0,
1213 .templateId = 3,
1214 .authType = static_cast<HdiAuthType>(1),
1215 .executorMatcher = 2,
1216 .executorSensorHint = 3,
1217 };
1218 infos.push_back(tempInfo);
1219 return HDF_SUCCESS;
1220 }
1221 );
1222 ResourceNodePool::Instance().Insert(nullptr);
1223 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1224 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1225 service.CancelAuthOrIdentify(conxtId);
1226 IpcCommon::DeleteAllPermission();
1227 }
1228
1229 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_016, TestSize.Level0)
1230 {
1231 UserAuthService service;
1232 int32_t apiVersion = 10;
1233 AuthParamInner authParam;
1234 authParam.challenge.push_back(1);
1235 authParam.authTypes.push_back(AuthType::PIN);
1236 authParam.authTrustLevel = ATL2;
1237 WidgetParam widgetParam;
1238 widgetParam.title = "使用密码验证";
1239 widgetParam.navigationButtonText = "";
1240 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1241 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1242 EXPECT_NE(testCallback, nullptr);
1243 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1244 EXPECT_NE(tempCallback, nullptr);
1245 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1246 IpcCommon::AddPermission(IS_SYSTEM_APP);
1247 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1248 int32_t acquire = 20;
1249 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1250 EXPECT_NE(mockHdi, nullptr);
1251 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41202(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1252 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1253 HdiCredentialInfo tempInfo = {
1254 .credentialId = 1,
1255 .executorIndex = 0,
1256 .templateId = 3,
1257 .authType = static_cast<HdiAuthType>(1),
1258 .executorMatcher = 2,
1259 .executorSensorHint = 3,
1260 };
1261 infos.push_back(tempInfo);
1262 return HDF_SUCCESS;
1263 }
1264 );
1265 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1266 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1267 ResourceNodePool::Instance().Insert(resourceNode1);
1268 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41302(const Attributes &condition, Attributes &values) 1269 [acquire](const Attributes &condition, Attributes &values) {
1270 return SUCCESS;
1271 }
1272 );
1273 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1274 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1275 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1276 service.CancelAuthOrIdentify(conxtId);
1277 IpcCommon::DeleteAllPermission();
1278 }
1279
1280 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0017, TestSize.Level0)
1281 {
1282 UserAuthService service;
1283 int32_t apiVersion = 10;
1284 AuthParamInner authParam;
1285 authParam.challenge.push_back(1);
1286 authParam.authTypes.push_back(AuthType::FINGERPRINT);
1287 authParam.authTrustLevel = ATL2;
1288 WidgetParam widgetParam;
1289 widgetParam.title = "使用密码验证";
1290 widgetParam.navigationButtonText = "";
1291 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1292 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1293 EXPECT_NE(testCallback, nullptr);
1294 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1295 EXPECT_NE(tempCallback, nullptr);
1296 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1297 IpcCommon::AddPermission(IS_SYSTEM_APP);
1298 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1299 int32_t acquire = 20;
1300 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1301 EXPECT_NE(mockHdi, nullptr);
1302 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41402(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1303 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1304 HdiCredentialInfo tempInfo = {
1305 .credentialId = 1,
1306 .executorIndex = 0,
1307 .templateId = 3,
1308 .authType = static_cast<HdiAuthType>(1),
1309 .executorMatcher = 2,
1310 .executorSensorHint = 3,
1311 };
1312 infos.push_back(tempInfo);
1313 return HDF_SUCCESS;
1314 }
1315 );
1316 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1317 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1318 ResourceNodePool::Instance().Insert(resourceNode1);
1319 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41502(const Attributes &condition, Attributes &values) 1320 [acquire](const Attributes &condition, Attributes &values) {
1321 values.SetStringValue(Attributes::ATTR_PIN_SUB_TYPE, "test");
1322 return SUCCESS;
1323 }
1324 );
1325 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1326 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1327 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1328 service.CancelAuthOrIdentify(conxtId);
1329 IpcCommon::DeleteAllPermission();
1330 }
1331
1332 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0018, TestSize.Level0)
1333 {
1334 UserAuthService service;
1335 int32_t apiVersion = 10;
1336 AuthParamInner authParam;
1337 authParam.challenge.push_back(1);
1338 authParam.authTypes.push_back(AuthType::FINGERPRINT);
1339 authParam.authTrustLevel = ATL2;
1340 WidgetParam widgetParam;
1341 widgetParam.title = "使用密码验证";
1342 widgetParam.navigationButtonText = "";
1343 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1344 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1345 EXPECT_NE(testCallback, nullptr);
1346 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1347 EXPECT_NE(tempCallback, nullptr);
1348 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1349 IpcCommon::AddPermission(IS_SYSTEM_APP);
1350 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1351 int32_t acquire = 20;
1352 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1353 EXPECT_NE(mockHdi, nullptr);
1354 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41602(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1355 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1356 HdiCredentialInfo tempInfo = {
1357 .credentialId = 1,
1358 .executorIndex = 0,
1359 .templateId = 3,
1360 .authType = static_cast<HdiAuthType>(1),
1361 };
1362 infos.push_back(tempInfo);
1363 return HDF_SUCCESS;
1364 }
1365 );
1366 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1367 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1368 ResourceNodePool::Instance().Insert(resourceNode1);
1369 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41702(const Attributes &condition, Attributes &values) 1370 [acquire](const Attributes &condition, Attributes &values) {
1371 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
1372 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
1373 return SUCCESS;
1374 }
1375 );
1376 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1377 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1378 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1379 service.CancelAuthOrIdentify(conxtId);
1380 IpcCommon::DeleteAllPermission();
1381 }
1382
1383 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0019, TestSize.Level0)
1384 {
1385 UserAuthService service;
1386 int32_t apiVersion = 10;
1387 AuthParamInner authParam;
1388 authParam.challenge.push_back(1);
1389 authParam.authTypes.push_back(AuthType::FINGERPRINT);
1390 authParam.authTrustLevel = ATL2;
1391 WidgetParam widgetParam;
1392 widgetParam.title = "使用密码验证";
1393 widgetParam.navigationButtonText = "";
1394 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1395 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1396 EXPECT_NE(testCallback, nullptr);
1397 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
1398 EXPECT_NE(tempCallback, nullptr);
1399 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
1400 IpcCommon::AddPermission(IS_SYSTEM_APP);
1401 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1402 int32_t acquire = 20;
1403 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1404 EXPECT_NE(mockHdi, nullptr);
1405 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41802(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1406 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1407 HdiCredentialInfo tempInfo = {
1408 .credentialId = 1,
1409 .executorIndex = 0,
1410 .templateId = 3,
1411 .authType = static_cast<HdiAuthType>(1),
1412 };
1413 infos.push_back(tempInfo);
1414 return HDF_SUCCESS;
1415 }
1416 );
1417 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1418 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1419 ResourceNodePool::Instance().Insert(resourceNode1);
1420 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41902(const Attributes &condition, Attributes &values) 1421 [acquire](const Attributes &condition, Attributes &values) {
1422 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
1423 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
1424 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
1425 return SUCCESS;
1426 }
1427 );
1428 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1429 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1430 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1431 service.CancelAuthOrIdentify(conxtId);
1432 IpcCommon::DeleteAllPermission();
1433 }
1434
1435 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0020, TestSize.Level0)
1436 {
1437 UserAuthService service;
1438 int32_t apiVersion = 10;
1439 AuthParamInner authParam;
1440 authParam.challenge.push_back(1);
1441 authParam.authTypes.push_back(AuthType::PIN);
1442 authParam.authTrustLevel = ATL2;
1443 WidgetParam widgetParam;
1444 widgetParam.title = "使用密码验证";
1445 widgetParam.navigationButtonText = "";
1446 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1447 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1448 EXPECT_NE(testCallback, nullptr);
1449 IpcCommon::AddPermission(IS_SYSTEM_APP);
1450 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1451 int32_t acquire = 20;
1452 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1453 EXPECT_NE(mockHdi, nullptr);
1454 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41a02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1455 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1456 HdiCredentialInfo tempInfo = {
1457 .credentialId = 1,
1458 .executorIndex = 0,
1459 .templateId = 3,
1460 .authType = static_cast<HdiAuthType>(0),
1461 };
1462 infos.push_back(tempInfo);
1463 return HDF_SUCCESS;
1464 }
1465 );
1466 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1467 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1468 ResourceNodePool::Instance().Insert(resourceNode1);
1469 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41b02(const Attributes &condition, Attributes &values) 1470 [acquire](const Attributes &condition, Attributes &values) {
1471 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
1472 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
1473 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
1474 values.SetInt32Value(Attributes::ATTR_FREEZING_TIME, acquire);
1475 return SUCCESS;
1476 }
1477 );
1478 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1479 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1480 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1481 IpcCommon::DeleteAllPermission();
1482 }
1483
1484 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0021, TestSize.Level0)
1485 {
1486 UserAuthService service;
1487 int32_t apiVersion = 10;
1488 AuthParamInner authParam;
1489 authParam.challenge.push_back(1);
1490 authParam.authTypes.push_back(AuthType::ALL);
1491 authParam.authTrustLevel = ATL2;
1492 WidgetParam widgetParam;
1493 widgetParam.title = "使用密码验证";
1494 widgetParam.navigationButtonText = "";
1495 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1496 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1497 EXPECT_NE(testCallback, nullptr);
1498 IpcCommon::AddPermission(IS_SYSTEM_APP);
1499 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1500 int32_t acquire = 20;
1501 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1502 EXPECT_NE(mockHdi, nullptr);
1503 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41c02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1504 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1505 HdiCredentialInfo tempInfo = {
1506 .credentialId = 1,
1507 .executorIndex = 0,
1508 .templateId = 3,
1509 .authType = static_cast<HdiAuthType>(0),
1510 };
1511 infos.push_back(tempInfo);
1512 return HDF_SUCCESS;
1513 }
1514 );
1515 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1516 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1517 ResourceNodePool::Instance().Insert(resourceNode1);
1518 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41d02(const Attributes &condition, Attributes &values) 1519 [acquire](const Attributes &condition, Attributes &values) {
1520 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
1521 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
1522 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
1523 values.SetInt32Value(Attributes::ATTR_FREEZING_TIME, acquire);
1524 return SUCCESS;
1525 }
1526 );
1527 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1528 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1529 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1530 IpcCommon::DeleteAllPermission();
1531 }
1532
1533 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_022, TestSize.Level0)
1534 {
1535 UserAuthService service;
1536 int32_t apiVersion = 10;
1537 AuthParamInner authParam;
1538 authParam.challenge.push_back(1);
1539 authParam.authTypes.push_back(AuthType::FINGERPRINT);
1540 authParam.authTrustLevel = ATL2;
1541 WidgetParam widgetParam;
1542 widgetParam.title = "使用密码验证";
1543 widgetParam.navigationButtonText = "";
1544 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1545 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1546 EXPECT_NE(testCallback, nullptr);
1547 IpcCommon::AddPermission(IS_SYSTEM_APP);
1548 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1549 int32_t acquire = 20;
1550 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1551 EXPECT_NE(mockHdi, nullptr);
1552 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anon4ff6fdb41e02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 1553 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
1554 HdiCredentialInfo tempInfo = {
1555 .credentialId = 1,
1556 .executorIndex = 0,
1557 .templateId = 3,
1558 .authType = static_cast<HdiAuthType>(1),
1559 };
1560 infos.push_back(tempInfo);
1561 return HDF_SUCCESS;
1562 }
1563 );
1564 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
1565 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
1566 ResourceNodePool::Instance().Insert(resourceNode1);
1567 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anon4ff6fdb41f02(const Attributes &condition, Attributes &values) 1568 [acquire](const Attributes &condition, Attributes &values) {
1569 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
1570 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
1571 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
1572 values.SetInt32Value(Attributes::ATTR_FREEZING_TIME, acquire);
1573 return SUCCESS;
1574 }
1575 );
1576 uint64_t conxtId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1577 EXPECT_NE(conxtId, INVALID_CONTEXT_ID);
1578 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
1579 IpcCommon::DeleteAllPermission();
1580 }
1581
1582 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_023, TestSize.Level0)
1583 {
1584 UserAuthService service;
1585 int32_t apiVersion = 10;
1586 AuthParamInner authParam;
1587 authParam.challenge.push_back(1);
1588 authParam.authTypes.push_back(AuthType::FINGERPRINT);
1589 authParam.authTrustLevel = ATL2;
1590 authParam.reuseUnlockResult.isReuse = true;
1591 authParam.reuseUnlockResult.reuseMode = AUTH_TYPE_IRRELEVANT;
1592 authParam.reuseUnlockResult.reuseDuration = 5 * 60 *1000;
1593 WidgetParam widgetParam;
1594 widgetParam.title = "使用密码验证";
1595 widgetParam.navigationButtonText = "";
1596 widgetParam.windowMode = WindowModeType::UNKNOWN_WINDOW_MODE;
1597 sptr<UserAuthCallbackInterface> testCallback = new MockUserAuthCallback();
1598 EXPECT_NE(testCallback, nullptr);
1599 IpcCommon::AddPermission(IS_SYSTEM_APP);
1600 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1601 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1602 EXPECT_NE(mockHdi, nullptr);
1603 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1604 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1605 EXPECT_CALL(*mockHdi, CheckReuseUnlockResult(_, _)).Times(1);
1606 ON_CALL(*mockHdi, CheckReuseUnlockResult)
1607 .WillByDefault(
__anon4ff6fdb42002(const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) 1608 [](const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) {
1609 static const uint32_t USER_AUTH_TOKEN_LEN = 148;
1610 reuseInfo.token.resize(USER_AUTH_TOKEN_LEN);
1611 return HDF_SUCCESS;
1612 }
1613 );
1614 uint64_t contextId = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback);
1615 EXPECT_EQ(contextId, REUSE_AUTH_RESULT_CONTEXT_ID);
1616 IpcCommon::DeleteAllPermission();
1617 }
1618
1619 HWTEST_F(UserAuthServiceTest, UserAuthServiceNotice_001, TestSize.Level0)
1620 {
1621 UserAuthService service;
1622 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1623 int32_t ret = service.Notice(NoticeType::WIDGET_NOTICE, "PIN");
1624 EXPECT_NE(ret, ResultCode::SUCCESS);
1625 IpcCommon::DeleteAllPermission();
1626 }
1627
1628 HWTEST_F(UserAuthServiceTest, UserAuthServiceNotice_002, TestSize.Level0)
1629 {
1630 UserAuthService service;
1631 IpcCommon::AddPermission(IS_SYSTEM_APP);
1632 int32_t ret = service.Notice(NoticeType::WIDGET_NOTICE, "PIN");
1633 EXPECT_EQ(ret, ResultCode::CHECK_PERMISSION_FAILED);
1634 IpcCommon::DeleteAllPermission();
1635 }
1636
1637 HWTEST_F(UserAuthServiceTest, UserAuthServiceNotice_003, TestSize.Level0)
1638 {
1639 UserAuthService service;
1640 IpcCommon::AddPermission(IS_SYSTEM_APP);
1641 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1642 int32_t ret = service.Notice(NoticeType::WIDGET_NOTICE, "PIN");
1643 EXPECT_EQ(ret, ResultCode::INVALID_PARAMETERS);
1644 IpcCommon::DeleteAllPermission();
1645 }
1646
1647 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_001, TestSize.Level0)
1648 {
1649 UserAuthService service;
1650 sptr<WidgetCallbackInterface> testCallback = nullptr;
1651 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::CHECK_SYSTEM_APP_FAILED);
1652 }
1653
1654 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_002, TestSize.Level0)
1655 {
1656 UserAuthService service;
1657 sptr<WidgetCallbackInterface> testCallback = nullptr;
1658 IpcCommon::AddPermission(IS_SYSTEM_APP);
1659 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::CHECK_PERMISSION_FAILED);
1660 IpcCommon::DeleteAllPermission();
1661 }
1662
1663 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_003, TestSize.Level0)
1664 {
1665 UserAuthService service;
1666 sptr<WidgetCallbackInterface> testCallback = nullptr;
1667 IpcCommon::AddPermission(IS_SYSTEM_APP);
1668 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1669 EXPECT_EQ(service.RegisterWidgetCallback(2, testCallback), ResultCode::INVALID_PARAMETERS);
1670 IpcCommon::DeleteAllPermission();
1671 }
1672
1673 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_004, TestSize.Level0)
1674 {
1675 UserAuthService service;
1676 sptr<WidgetCallbackInterface> testCallback = nullptr;
1677 IpcCommon::AddPermission(IS_SYSTEM_APP);
1678 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1679 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::INVALID_PARAMETERS);
1680 IpcCommon::DeleteAllPermission();
1681 }
1682
1683 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_005, TestSize.Level0)
1684 {
1685 UserAuthService service;
1686 sptr<WidgetCallbackInterface> testCallback = new MockWidgetCallbackInterface();
1687 IpcCommon::AddPermission(IS_SYSTEM_APP);
1688 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1689 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::SUCCESS);
1690 IpcCommon::DeleteAllPermission();
1691 }
1692
1693 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_006, TestSize.Level0)
1694 {
1695 UserAuthService service;
1696 sptr<WidgetCallbackInterface> testCallback = nullptr;
1697 IpcCommon::AddPermission(IS_SYSTEM_APP);
1698 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::CHECK_PERMISSION_FAILED);
1699 IpcCommon::DeleteAllPermission();
1700 }
1701
1702 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_001, TestSize.Level0)
1703 {
1704 UserAuthService service;
1705 sptr<AuthEventListenerInterface> testCallback = nullptr;
1706 std::vector<AuthType> authTypeList;
1707 IpcCommon::AddPermission(IS_SYSTEM_APP);
1708 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(authTypeList, testCallback), ResultCode::INVALID_PARAMETERS);
1709 IpcCommon::DeleteAllPermission();
1710 }
1711
1712 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_002, TestSize.Level0)
1713 {
1714 UserAuthService service;
1715 sptr<AuthEventListenerInterface> testCallback = new MockAuthEventListener();
1716 std::vector<AuthType> authTypeList;
1717 IpcCommon::AddPermission(IS_SYSTEM_APP);
1718 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(authTypeList, testCallback),
1719 ResultCode::INVALID_PARAMETERS);
1720 IpcCommon::DeleteAllPermission();
1721 }
1722
1723 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_003, TestSize.Level0)
1724 {
1725 UserAuthService service;
1726 sptr<AuthEventListenerInterface> testCallback = new MockAuthEventListener();
1727 std::vector<AuthType> authTypeList;
1728 authTypeList.push_back(AuthType::PIN);
1729 authTypeList.push_back(AuthType::FACE);
1730 authTypeList.push_back(AuthType::FINGERPRINT);
1731 IpcCommon::AddPermission(IS_SYSTEM_APP);
1732 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(authTypeList, testCallback),
1733 ResultCode::CHECK_PERMISSION_FAILED);
1734 IpcCommon::DeleteAllPermission();
1735 }
1736
1737 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_004, TestSize.Level0)
1738 {
1739 UserAuthService service;
1740 sptr<AuthEventListenerInterface> testCallback = new MockAuthEventListener();
1741 std::vector<AuthType> authTypeList;
1742 authTypeList.push_back(AuthType::PIN);
1743 authTypeList.push_back(AuthType::FACE);
1744 authTypeList.push_back(AuthType::FINGERPRINT);
1745 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1746 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(authTypeList, testCallback), ResultCode::GENERAL_ERROR);
1747 IpcCommon::DeleteAllPermission();
1748 }
1749
1750 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_001, TestSize.Level0)
1751 {
1752 UserAuthService service;
1753 sptr<AuthEventListenerInterface> testCallback = nullptr;
1754 IpcCommon::AddPermission(IS_SYSTEM_APP);
1755 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::INVALID_PARAMETERS);
1756 IpcCommon::DeleteAllPermission();
1757 }
1758
1759 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_002, TestSize.Level0)
1760 {
1761 UserAuthService service;
1762 sptr<AuthEventListenerInterface> testCallback = new MockAuthEventListener();
1763 IpcCommon::AddPermission(IS_SYSTEM_APP);
1764 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::CHECK_PERMISSION_FAILED);
1765 IpcCommon::DeleteAllPermission();
1766 }
1767
1768 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_003, TestSize.Level0)
1769 {
1770 UserAuthService service;
1771 sptr<AuthEventListenerInterface> testCallback = new MockAuthEventListener();
1772 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1773 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::GENERAL_ERROR);
1774 IpcCommon::DeleteAllPermission();
1775 }
1776
1777 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_004, TestSize.Level0)
1778 {
1779 UserAuthService service;
1780 sptr<AuthEventListenerInterface> testCallback = new MockAuthEventListener();
1781 std::vector<AuthType> authTypeList;
1782 authTypeList.push_back(AuthType::PIN);
1783 authTypeList.push_back(AuthType::FACE);
1784 authTypeList.push_back(AuthType::FINGERPRINT);
1785 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1786 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(authTypeList, testCallback), ResultCode::GENERAL_ERROR);
1787 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::GENERAL_ERROR);
1788 IpcCommon::DeleteAllPermission();
1789 }
1790
1791 HWTEST_F(UserAuthServiceTest, UserAuthServiceSetGlobalConfigParam, TestSize.Level0)
1792 {
1793 UserAuthService service;
1794 GlobalConfigParam param = {};
1795 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::CHECK_PERMISSION_FAILED);
1796
1797 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1798 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1799
1800 param.type = PIN_EXPIRED_PERIOD;
1801 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::SUCCESS);
1802
1803
1804 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1805 EXPECT_NE(mockHdi, nullptr);
1806 EXPECT_CALL(*mockHdi, SetGlobalConfigParam(_)).Times(1);
1807 ON_CALL(*mockHdi, SetGlobalConfigParam)
1808 .WillByDefault(
__anon4ff6fdb42102(const HdiGlobalConfigParam ¶m) 1809 [](const HdiGlobalConfigParam ¶m) {
1810 return HDF_SUCCESS;
1811 }
1812 );
1813 EXPECT_EQ(service.SetGlobalConfigParam(param), HDF_SUCCESS);
1814 IpcCommon::DeleteAllPermission();
1815 }
1816 } // namespace UserAuth
1817 } // namespace UserIam
1818 } // namespace OHOS