1 /*
2 * Copyright (C) 2022 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_idm_service_test.h"
17
18 #include <future>
19
20 #include "iam_common_defines.h"
21 #include "iam_ptr.h"
22
23 #include "context_pool.h"
24 #include "executor_messenger_service.h"
25 #include "mock_context.h"
26 #include "mock_ipc_common.h"
27 #include "mock_iuser_auth_interface.h"
28 #include "mock_resource_node.h"
29 #include "mock_user_idm_callback.h"
30 #include "resource_node_pool.h"
31 #include "user_idm_service.h"
32
33 namespace OHOS {
34 namespace UserIam {
35 namespace UserAuth {
36 using namespace testing;
37 using namespace testing::ext;
SetUpTestCase()38 void UserIdmServiceTest::SetUpTestCase()
39 {
40 }
41
TearDownTestCase()42 void UserIdmServiceTest::TearDownTestCase()
43 {
44 }
45
SetUp()46 void UserIdmServiceTest::SetUp()
47 {
48 MockIUserAuthInterface::Holder::GetInstance().Reset();
49 }
50
TearDown()51 void UserIdmServiceTest::TearDown()
52 {
53 MockIUserAuthInterface::Holder::GetInstance().Reset();
54 }
55
56 HWTEST_F(UserIdmServiceTest, UserIdmServiceOpenSession_001, TestSize.Level0)
57 {
58 UserIdmService service(123123, true);
59 int32_t testUserId = 0;
60 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
61 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
62 EXPECT_NE(mockHdi, nullptr);
63 EXPECT_CALL(*mockHdi, OpenSession(_, _)).Times(1);
64 ON_CALL(*mockHdi, OpenSession)
65 .WillByDefault(
__anon62a1d9640102(int32_t userId, std::vector<uint8_t> &challenge) 66 [&testChallenge](int32_t userId, std::vector<uint8_t> &challenge) {
67 challenge = testChallenge;
68 return HDF_SUCCESS;
69 }
70 );
71 std::vector<uint8_t> challenge;
72 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
73 int32_t ret = service.OpenSession(testUserId, challenge);
74 EXPECT_EQ(ret, SUCCESS);
75 EXPECT_THAT(challenge, ElementsAreArray(testChallenge));
76 IpcCommon::DeleteAllPermission();
77 }
78
79 HWTEST_F(UserIdmServiceTest, UserIdmServiceOpenSession_002, TestSize.Level0)
80 {
81 UserIdmService service(123123, true);
82 int32_t testUserId = 0;
83 std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
84
85 std::vector<uint8_t> challenge;
86 int32_t ret = service.OpenSession(testUserId, challenge);
87 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
88
89 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
90 auto context = Common::MakeShared<MockContext>();
91 EXPECT_NE(context, nullptr);
92 EXPECT_CALL(*context, GetContextType()).WillRepeatedly(Return(CONTEXT_ENROLL));
93 EXPECT_CALL(*context, GetContextId()).WillRepeatedly(Return(2345));
94 EXPECT_CALL(*context, Stop()).WillRepeatedly(Return(true));
95 EXPECT_TRUE(ContextPool::Instance().Insert(context));
96
97 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
98 EXPECT_NE(mockHdi, nullptr);
99 EXPECT_CALL(*mockHdi, OpenSession(_, _))
100 .Times(3)
101 .WillOnce(Return(HDF_SUCCESS))
102 .WillOnce(Return(HDF_SUCCESS))
103 .WillOnce(Return(HDF_FAILURE));
104
105 EXPECT_EQ(service.OpenSession(testUserId, challenge), SUCCESS);
106 EXPECT_EQ(service.OpenSession(testUserId, challenge), SUCCESS);
107 EXPECT_EQ(service.OpenSession(testUserId, challenge), GENERAL_ERROR);
108
109 IpcCommon::DeleteAllPermission();
110 }
111
112 HWTEST_F(UserIdmServiceTest, UserIdmServiceCloseSession, TestSize.Level0)
113 {
114 UserIdmService service(123123, true);
115 int32_t testUserId = 3546;
116
117 service.CloseSession(testUserId);
118 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
119 EXPECT_NE(mockHdi, nullptr);
120 EXPECT_CALL(*mockHdi, CloseSession(_))
121 .Times(2)
122 .WillOnce(Return(HDF_SUCCESS))
123 .WillOnce(Return(HDF_FAILURE));
124 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
125 service.CloseSession(testUserId);
126 service.CloseSession(testUserId);
127 IpcCommon::DeleteAllPermission();
128 }
129
130 HWTEST_F(UserIdmServiceTest, UserIdmServiceGetCredentialInfo001, TestSize.Level0)
131 {
132 UserIdmService service(123123, true);
133 int32_t testUserId = 0;
134 AuthType testAuthType = PIN;
135
136 sptr<MockIdmGetCredentialInfoCallback> testCallback(new (std::nothrow) MockIdmGetCredentialInfoCallback());
137 EXPECT_NE(testCallback, nullptr);
138 EXPECT_CALL(*testCallback, OnCredentialInfos(_)).Times(2);
139
140 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
141 EXPECT_NE(mockHdi, nullptr);
142 EXPECT_CALL(*mockHdi, GetCredential(_, _, _)).WillOnce(Return(HDF_FAILURE));
143 int32_t ret = service.GetCredentialInfo(testUserId, testAuthType, testCallback);
144 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
145 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
146 ret = service.GetCredentialInfo(testUserId, testAuthType, testCallback);
147 EXPECT_EQ(ret, NOT_ENROLLED);
148 IpcCommon::DeleteAllPermission();
149 }
150
151 HWTEST_F(UserIdmServiceTest, UserIdmServiceGetCredentialInfo002, TestSize.Level0)
152 {
153 UserIdmService service(123123, true);
154 int32_t testUserId = 0;
155 AuthType testAuthType = PIN;
156 sptr<IdmGetCredInfoCallbackInterface> testCallback(nullptr);
157 int32_t ret = service.GetCredentialInfo(testUserId, testAuthType, testCallback);
158 EXPECT_EQ(ret, INVALID_PARAMETERS);
159 }
160
161 HWTEST_F(UserIdmServiceTest, UserIdmServiceGetCredentialInfo003, TestSize.Level0)
162 {
163 UserIdmService service(123123, true);
164 int32_t testUserId = 0;
165 AuthType testAuthType = PIN;
166 sptr<MockIdmGetCredentialInfoCallback> testCallback(new (std::nothrow) MockIdmGetCredentialInfoCallback());
167 EXPECT_NE(testCallback, nullptr);
168 EXPECT_CALL(*testCallback, OnCredentialInfos(_)).Times(2);
169
170 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
171 EXPECT_NE(mockHdi, nullptr);
172 EXPECT_CALL(*mockHdi, GetCredential(_, _, _)).Times(2);
173 ON_CALL(*mockHdi, GetCredential)
174 .WillByDefault(
__anon62a1d9640202(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 175 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
176 HdiCredentialInfo tempInfo = {
177 .credentialId = 1,
178 .executorIndex = 2,
179 .templateId = 3,
180 .authType = static_cast<HdiAuthType>(1),
181 .executorMatcher = 2,
182 .executorSensorHint = 3,
183 };
184 infos.push_back(tempInfo);
185 return HDF_SUCCESS;
186 }
187 );
188 EXPECT_CALL(*mockHdi, GetUserInfo(_, _, _, _))
189 .Times(2)
190 .WillOnce(Return(HDF_FAILURE))
191 .WillOnce(
__anon62a1d9640302(int32_t userId, uint64_t &secureUid, int32_t& pinSubType, std::vector<HdiEnrolledInfo> &infos) 192 [](int32_t userId, uint64_t &secureUid, int32_t& pinSubType, std::vector<HdiEnrolledInfo> &infos) {
193 HdiEnrolledInfo info = {
194 .enrolledId = 0,
195 .authType = static_cast<HdiAuthType>(1),
196 };
197 infos.push_back(info);
198 pinSubType = static_cast<HdiPinSubType>(10000);
199 secureUid = 4542;
200 return HDF_SUCCESS;
201 }
202 );
203
204 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
205 int32_t ret = service.GetCredentialInfo(testUserId, testAuthType, testCallback);
206 EXPECT_EQ(ret, GENERAL_ERROR);
207 ret = service.GetCredentialInfo(testUserId, testAuthType, testCallback);
208 EXPECT_EQ(ret, SUCCESS);
209 IpcCommon::DeleteAllPermission();
210 }
211
212 HWTEST_F(UserIdmServiceTest, UserIdmServiceGetCredentialInfo004, TestSize.Level0)
213 {
214 UserIdmService service(123123, true);
215 int32_t testUserId = 0;
216 AuthType testAuthType = PIN;
217 sptr<MockIdmGetCredentialInfoCallback> testCallback(new (std::nothrow) MockIdmGetCredentialInfoCallback());
218 EXPECT_NE(testCallback, nullptr);
219 EXPECT_CALL(*testCallback, OnCredentialInfos(_)).Times(1);
220
221 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
222 EXPECT_NE(mockHdi, nullptr);
223 EXPECT_CALL(*mockHdi, GetCredential(_, _, _))
224 .WillOnce(
__anon62a1d9640402(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 225 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
226 HdiCredentialInfo tempInfo = {
227 .credentialId = 1,
228 .executorIndex = 2,
229 .templateId = 3,
230 .authType = static_cast<HdiAuthType>(2),
231 .executorMatcher = 2,
232 .executorSensorHint = 3,
233 };
234 infos.push_back(tempInfo);
235 return HDF_SUCCESS;
236 }
237 );
238
239 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
240 int32_t ret = service.GetCredentialInfo(testUserId, testAuthType, testCallback);
241 EXPECT_EQ(ret, SUCCESS);
242 IpcCommon::DeleteAllPermission();
243 }
244
245 HWTEST_F(UserIdmServiceTest, UserIdmServiceGetSecInfo001, TestSize.Level0)
246 {
247 UserIdmService service(123123, true);
248 int32_t testUserId = 0;
249
250 sptr<MockIdmGetSecureUserInfoCallback> testCallback(new (std::nothrow) MockIdmGetSecureUserInfoCallback());
251 EXPECT_NE(testCallback, nullptr);
252 EXPECT_CALL(*testCallback, OnSecureUserInfo(_)).Times(2);
253
254 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
255 EXPECT_NE(mockHdi, nullptr);
256 EXPECT_CALL(*mockHdi, GetUserInfo(_, _, _, _)).WillOnce(Return(HDF_FAILURE));
257
258 int32_t ret = service.GetSecInfo(testUserId, testCallback);
259 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
260 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
261 ret = service.GetSecInfo(testUserId, testCallback);
262 EXPECT_EQ(ret, GENERAL_ERROR);
263 IpcCommon::DeleteAllPermission();
264 }
265
266 HWTEST_F(UserIdmServiceTest, UserIdmServiceGetSecInfo002, TestSize.Level0)
267 {
268 UserIdmService service(123123, true);
269 int32_t testUserId = 0;
270 sptr<MockIdmGetSecureUserInfoCallback> testCallback(nullptr);
271 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
272 int32_t ret = service.GetSecInfo(testUserId, testCallback);
273 EXPECT_EQ(ret, INVALID_PARAMETERS);
274
275 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
276 EXPECT_NE(mockHdi, nullptr);
277 EXPECT_CALL(*mockHdi, GetUserInfo(_, _, _, _))
278 .Times(2)
279 .WillOnce(Return(HDF_FAILURE))
280 .WillOnce(
__anon62a1d9640502(int32_t userId, uint64_t &secureUid, int32_t& pinSubType, std::vector<HdiEnrolledInfo> &infos) 281 [](int32_t userId, uint64_t &secureUid, int32_t& pinSubType, std::vector<HdiEnrolledInfo> &infos) {
282 HdiEnrolledInfo info = {
283 .enrolledId = 0,
284 .authType = static_cast<HdiAuthType>(1),
285 };
286 infos.push_back(info);
287 pinSubType = static_cast<HdiPinSubType>(10000);
288 secureUid = 4542;
289 return HDF_SUCCESS;
290 }
291 );
292
293 testCallback = sptr<MockIdmGetSecureUserInfoCallback>(new (std::nothrow) MockIdmGetSecureUserInfoCallback());
294 EXPECT_NE(testCallback, nullptr);
295 EXPECT_CALL(*testCallback, OnSecureUserInfo(_)).Times(2);
296 ret = service.GetSecInfo(testUserId, testCallback);
297 EXPECT_EQ(ret, GENERAL_ERROR);
298 ret = service.GetSecInfo(testUserId, testCallback);
299 EXPECT_EQ(ret, SUCCESS);
300 IpcCommon::DeleteAllPermission();
301 }
302
303 HWTEST_F(UserIdmServiceTest, UserIdmServiceAddCredential001, TestSize.Level0)
304 {
305 UserIdmService service(123123, true);
306 int32_t testUserId = 15457;
307 UserIdmInterface::CredentialPara testCredPara = {};
308 testCredPara.authType = PIN;
309 testCredPara.pinType = PIN_SIX;
310 testCredPara.token = {1, 2, 3, 4};
311 sptr<IdmCallbackInterface> testCallback(nullptr);
312 service.AddCredential(testUserId, testCredPara, testCallback, false);
313 }
314
315 HWTEST_F(UserIdmServiceTest, UserIdmServiceAddCredential002, TestSize.Level0)
316 {
317 UserIdmService service(123123, true);
318 int32_t testUserId = 15457;
319 UserIdmInterface::CredentialPara testCredPara = {};
320 testCredPara.authType = PIN;
321 testCredPara.pinType = PIN_SIX;
322 testCredPara.token = {1, 2, 3, 4};
323 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
324 EXPECT_NE(testCallback, nullptr);
325 EXPECT_CALL(*testCallback, OnResult(_, _))
326 .Times(2)
327 .WillOnce(
__anon62a1d9640602(int32_t result, const Attributes &extraInfo) 328 [](int32_t result, const Attributes &extraInfo) {
329 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
330 }
331 )
332 .WillOnce(
__anon62a1d9640702(int32_t result, const Attributes &extraInfo) 333 [](int32_t result, const Attributes &extraInfo) {
334 EXPECT_EQ(result, HDF_FAILURE);
335 }
336 );
337 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
338 EXPECT_NE(mockHdi, nullptr);
339 EXPECT_CALL(*mockHdi, BeginEnrollment(_, _, _)).WillRepeatedly(Return(HDF_FAILURE));
340
341 service.AddCredential(testUserId, testCredPara, testCallback, false);
342 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
343 service.AddCredential(testUserId, testCredPara, testCallback, false);
344 IpcCommon::DeleteAllPermission();
345 }
346
MockForAddCredentialHdi(std::shared_ptr<Context> & context,std::promise<void> & promise)347 static void MockForAddCredentialHdi(std::shared_ptr<Context> &context, std::promise<void> &promise)
348 {
349 const uint32_t testExecutorIndex = 60;
350 const uint32_t testscheduleId = 20;
351 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
352 EXPECT_NE(mockHdi, nullptr);
353 EXPECT_CALL(*mockHdi, BeginEnrollment(_, _, _))
354 .WillOnce([&context](const std::vector<uint8_t> &authToken, const HdiEnrollParam ¶m,
355 HdiScheduleInfo &info) {
356 info.executorIndexes.push_back(testExecutorIndex);
357 std::vector<uint8_t> executorMessages;
358 executorMessages.resize(1);
359 info.executorMessages.push_back(executorMessages);
360 info.scheduleId = testscheduleId;
361 info.authType = HdiAuthType::FACE;
362 auto contextList = ContextPool::Instance().Select(CONTEXT_ENROLL);
363 if (!contextList.empty()) {
364 context = contextList[0].lock();
365 }
366 return HDF_SUCCESS;
367 });
368
369 EXPECT_CALL(*mockHdi, UpdateEnrollmentResult(_, _, _)).WillOnce(Return(HDF_SUCCESS));
370 EXPECT_CALL(*mockHdi, CancelEnrollment(_))
371 .WillOnce([&promise](int32_t userId) {
372 promise.set_value();
373 return HDF_SUCCESS;
374 });
375 }
376
MockForIdmResourceNode(std::shared_ptr<MockResourceNode> & resourceNode)377 static void MockForIdmResourceNode(std::shared_ptr<MockResourceNode> &resourceNode)
378 {
379 const uint32_t testScheduleId = 20;
380 const uint32_t testExecutorIndex = 60;
381 EXPECT_CALL(*resourceNode, GetExecutorIndex()).WillRepeatedly(Return(testExecutorIndex));
382 EXPECT_CALL(*resourceNode, GetAuthType()).WillRepeatedly(Return(FACE));
383 EXPECT_CALL(*resourceNode, GetExecutorRole()).WillRepeatedly(Return(ALL_IN_ONE));
384 EXPECT_CALL(*resourceNode, GetExecutorMatcher()).WillRepeatedly(Return(0));
385 EXPECT_CALL(*resourceNode, GetExecutorPublicKey()).WillRepeatedly(Return(std::vector<uint8_t>()));
386 EXPECT_CALL(*resourceNode, BeginExecute(_, _, _))
387 .WillOnce([](uint64_t scheduleId, const std::vector<uint8_t> &publicKey, const Attributes &command) {
388 auto messenger = ExecutorMessengerService::GetInstance();
389 EXPECT_NE(messenger, nullptr);
390 auto finalResult = Common::MakeShared<Attributes>();
391 EXPECT_NE(finalResult, nullptr);
392 std::vector<uint8_t> scheduleResult = {1, 2, 3, 4};
393 EXPECT_TRUE(finalResult->SetUint8ArrayValue(Attributes::ATTR_RESULT, scheduleResult));
394 EXPECT_EQ(messenger->Finish(testScheduleId, SUCCESS, finalResult), SUCCESS);
395 return SUCCESS;
396 });
397 }
398
399 HWTEST_F(UserIdmServiceTest, UserIdmServiceAddCredential003, TestSize.Level0)
400 {
401 UserIdmService service(123123, true);
402 int32_t testUserId = 15457;
403 UserIdmInterface::CredentialPara testCredPara = {};
404 testCredPara.authType = FACE;
405 testCredPara.pinType = PIN_SIX;
406 testCredPara.token = {1, 2, 3, 4};
407 std::shared_ptr<Context> context = nullptr;
408
409 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
410 EXPECT_NE(testCallback, nullptr);
411 EXPECT_CALL(*testCallback, OnResult(_, _))
412 .WillOnce(
__anon62a1d9640b02(int32_t result, const Attributes &extraInfo) 413 [&context](int32_t result, const Attributes &extraInfo) {
414 EXPECT_EQ(result, SUCCESS);
415 if (context != nullptr) {
416 context->Stop();
417 }
418 }
419 );
420 std::promise<void> promise;
421 MockForAddCredentialHdi(context, promise);
422
423 auto resourceNode = Common::MakeShared<MockResourceNode>();
424 EXPECT_NE(resourceNode, nullptr);
425 MockForIdmResourceNode(resourceNode);
426
427 EXPECT_TRUE(ResourceNodePool::Instance().Insert(resourceNode));
428
429 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
430 service.AddCredential(testUserId, testCredPara, testCallback, false);
431 promise.get_future().get();
432
433 EXPECT_TRUE(ResourceNodePool::Instance().Delete(60));
434 IpcCommon::DeleteAllPermission();
435 }
436
437 HWTEST_F(UserIdmServiceTest, UserIdmServiceUpdateCredential001, TestSize.Level0)
438 {
439 UserIdmService service(123123, true);
440 int32_t testUserId = 1548545;
441 UserIdmInterface::CredentialPara testCredPara = {};
442 testCredPara.authType = FACE;
443 testCredPara.pinType = PIN_SIX;
444 testCredPara.token = {1, 2, 3, 4};
445 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
446 EXPECT_NE(testCallback, nullptr);
447 EXPECT_CALL(*testCallback, OnResult(_, _))
448 .WillOnce(
__anon62a1d9640c02(int32_t result, const Attributes &extraInfo) 449 [](int32_t result, const Attributes &extraInfo) {
450 EXPECT_EQ(result, NOT_ENROLLED);
451 }
452 );
453 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
454 EXPECT_NE(mockHdi, nullptr);
455 EXPECT_CALL(*mockHdi, GetCredential(_, _, _)).WillRepeatedly(Return(HDF_SUCCESS));
456 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
457 service.UpdateCredential(testUserId, testCredPara, testCallback);
458 IpcCommon::DeleteAllPermission();
459 }
460
461 HWTEST_F(UserIdmServiceTest, UserIdmServiceUpdateCredential002, TestSize.Level0)
462 {
463 UserIdmService service(123123, true);
464 int32_t testUserId = 1548545;
465 UserIdmInterface::CredentialPara testCredPara = {};
466 testCredPara.authType = FACE;
467 testCredPara.pinType = PIN_SIX;
468 sptr<MockIdmCallback> testCallback(nullptr);
469
470 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
471 service.UpdateCredential(testUserId, testCredPara, testCallback);
472
473 testCallback = sptr<MockIdmCallback>(new (std::nothrow) MockIdmCallback());
474 EXPECT_NE(testCallback, nullptr);
475 EXPECT_CALL(*testCallback, OnResult(_, _))
476 .WillOnce(
__anon62a1d9640d02(int32_t result, const Attributes &extraInfo) 477 [](int32_t result, const Attributes &extraInfo) {
478 EXPECT_EQ(result, HDF_FAILURE);
479 }
480 );
481
482 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
483 EXPECT_NE(mockHdi, nullptr);
484 EXPECT_CALL(*mockHdi, GetCredential(_, _, _))
485 .WillOnce(
__anon62a1d9640e02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 486 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
487 HdiCredentialInfo tempInfo = {
488 .credentialId = 1,
489 .executorIndex = 2,
490 .templateId = 3,
491 .authType = static_cast<HdiAuthType>(2),
492 .executorMatcher = 2,
493 .executorSensorHint = 3,
494 };
495 infos.push_back(tempInfo);
496 return HDF_SUCCESS;
497 }
498 );
499
500 EXPECT_CALL(*mockHdi, BeginEnrollment(_, _, _)).WillOnce(Return(HDF_FAILURE));
501
502 testCredPara.token = {1, 2, 3, 4};
503 service.UpdateCredential(testUserId, testCredPara, testCallback);
504 IpcCommon::DeleteAllPermission();
505 }
506
507 HWTEST_F(UserIdmServiceTest, UserIdmServiceCancel001, TestSize.Level0)
508 {
509 UserIdmService service(123123, true);
510 int32_t testUserId = 154835;
511 int32_t ret = service.Cancel(testUserId);
512 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
513 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
514 ret = service.Cancel(testUserId);
515 EXPECT_EQ(ret, GENERAL_ERROR);
516 IpcCommon::DeleteAllPermission();
517 }
518
519 HWTEST_F(UserIdmServiceTest, UserIdmServiceCancel002, TestSize.Level0)
520 {
521 UserIdmService service(123123, true);
522 int32_t testUserId = 69874;
523 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
524 EXPECT_NE(mockHdi, nullptr);
525 EXPECT_CALL(*mockHdi, OpenSession(_, _)).WillOnce(Return(HDF_SUCCESS));
526
527 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
528 std::vector<uint8_t> challenge;
529 int32_t ret = service.OpenSession(testUserId, challenge);
530 EXPECT_EQ(ret, SUCCESS);
531 ret = service.Cancel(testUserId);
532 EXPECT_EQ(ret, GENERAL_ERROR);
533 IpcCommon::DeleteAllPermission();
534 }
535
536 HWTEST_F(UserIdmServiceTest, UserIdmServiceCancel003, TestSize.Level0)
537 {
538 UserIdmService service(123123, true);
539 int32_t testUserId = 96874;
540 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
541 EXPECT_NE(mockHdi, nullptr);
542 EXPECT_CALL(*mockHdi, OpenSession(_, _)).WillOnce(Return(HDF_SUCCESS));
543
544 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
545 std::vector<uint8_t> challenge;
546 int32_t ret = service.OpenSession(testUserId, challenge);
547 EXPECT_EQ(ret, SUCCESS);
548
549 auto context = Common::MakeShared<MockContext>();
550 EXPECT_NE(context, nullptr);
551 EXPECT_CALL(*context, GetContextType()).WillRepeatedly(Return(CONTEXT_ENROLL));
552 EXPECT_CALL(*context, GetContextId()).WillRepeatedly(Return(2345));
553 EXPECT_CALL(*context, Stop()).WillRepeatedly(Return(true));
554 EXPECT_TRUE(ContextPool::Instance().Insert(context));
555
556 ret = service.Cancel(testUserId);
557 EXPECT_EQ(ret, SUCCESS);
558 IpcCommon::DeleteAllPermission();
559 }
560
561 HWTEST_F(UserIdmServiceTest, UserIdmServiceEnforceDelUser001, TestSize.Level0)
562 {
563 UserIdmService service(123123, true);
564 int32_t testUserId = 15485;
565 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
566 EXPECT_NE(testCallback, nullptr);
567 EXPECT_CALL(*testCallback, OnResult(_, _))
568 .Times(2)
569 .WillOnce(
__anon62a1d9640f02(int32_t result, const Attributes &extraInfo) 570 [](int32_t result, const Attributes &extraInfo) {
571 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
572 }
573 )
574 .WillOnce(
__anon62a1d9641002(int32_t result, const Attributes &extraInfo) 575 [](int32_t result, const Attributes &extraInfo) {
576 EXPECT_EQ(result, GENERAL_ERROR);
577 }
578 );
579
580 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
581 EXPECT_NE(mockHdi, nullptr);
582 EXPECT_CALL(*mockHdi, GetUserInfo(_, _, _, _)).WillOnce(Return(HDF_FAILURE));
583
584 int32_t ret = service.EnforceDelUser(testUserId, testCallback);
585 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
586 IpcCommon::AddPermission(ENFORCE_USER_IDM);
587 ret = service.EnforceDelUser(testUserId, testCallback);
588 EXPECT_EQ(ret, GENERAL_ERROR);
589 IpcCommon::DeleteAllPermission();
590 }
591
592 HWTEST_F(UserIdmServiceTest, UserIdmServiceEnforceDelUser002, TestSize.Level0)
593 {
594 UserIdmService service(123123, true);
595 int32_t testUserId = 15485;
596 sptr<IdmCallbackInterface> testCallback(nullptr);
597 int32_t ret = service.EnforceDelUser(testUserId, testCallback);
598 EXPECT_EQ(ret, INVALID_PARAMETERS);
599 }
600
MockForDelUserHdi()601 static void MockForDelUserHdi()
602 {
603 const uint32_t testAuthType = 1;
604 const uint32_t testCredentialId = 10;
605 const uint32_t testExecutorIndex = 20;
606 const uint32_t testExecutorMatcher = 30;
607 const uint32_t testExecutorSensorHint = 40;
608 const uint32_t testTemplateId = 50;
609 const uint32_t testSecureUid = 4542;
610 const uint32_t testTimes = 2;
611 const uint32_t testPinSubType = 10000;
612 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
613 EXPECT_NE(mockHdi, nullptr);
614 EXPECT_CALL(*mockHdi, GetUserInfo(_, _, _, _))
615 .WillRepeatedly([](int32_t userId, uint64_t &secureUid, int32_t& pinSubType,
616 std::vector<HdiEnrolledInfo> &infos) {
617 HdiEnrolledInfo info = {
618 .enrolledId = 0,
619 .authType = static_cast<HdiAuthType>(1),
620 };
621 infos.push_back(info);
622 pinSubType = static_cast<HdiPinSubType>(testPinSubType);
623 secureUid = testSecureUid;
624 return HDF_SUCCESS;
625 });
626
627 EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _))
628 .Times(testTimes)
629 .WillOnce(Return(HDF_FAILURE))
630 .WillOnce([](int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) {
631 HdiCredentialInfo info = {};
632 info.authType = static_cast<HdiAuthType>(testAuthType);
633 info.credentialId = testCredentialId;
634 info.executorIndex = testExecutorIndex;
635 info.executorMatcher = testExecutorMatcher;
636 info.executorSensorHint = testExecutorSensorHint;
637 info.templateId = testTemplateId;
638 deletedInfos.emplace_back(info);
639 return HDF_SUCCESS;
640 });
641 }
642
643 HWTEST_F(UserIdmServiceTest, UserIdmServiceEnforceDelUser003, TestSize.Level0)
644 {
645 UserIdmService service(123123, true);
646 int32_t testUserId = 15485;
647 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
648 EXPECT_NE(testCallback, nullptr);
649 EXPECT_CALL(*testCallback, OnResult(_, _))
650 .Times(2)
651 .WillOnce(
__anon62a1d9641302(int32_t result, const Attributes &extraInfo) 652 [](int32_t result, const Attributes &extraInfo) {
653 EXPECT_EQ(result, HDF_FAILURE);
654 }
655 )
656 .WillOnce(
__anon62a1d9641402(int32_t result, const Attributes &extraInfo) 657 [](int32_t result, const Attributes &extraInfo) {
658 EXPECT_EQ(result, SUCCESS);
659 }
660 );
661 MockForDelUserHdi();
662 IpcCommon::AddPermission(ENFORCE_USER_IDM);
663 int32_t ret = service.EnforceDelUser(testUserId, testCallback);
664 EXPECT_EQ(ret, -1);
665 ret = service.EnforceDelUser(testUserId, testCallback);
666 EXPECT_EQ(ret, SUCCESS);
667 IpcCommon::DeleteAllPermission();
668 }
669
670 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelUser001, TestSize.Level0)
671 {
672 UserIdmService service(123123, true);
673 int32_t testUserId = 15486465;
674 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
675
676 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
677 EXPECT_NE(testCallback, nullptr);
678 EXPECT_CALL(*testCallback, OnResult(_, _))
679 .Times(2)
680 .WillOnce(
__anon62a1d9641502(int32_t result, const Attributes &extraInfo) 681 [](int32_t result, const Attributes &extraInfo) {
682 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
683 }
684 )
685 .WillOnce(
__anon62a1d9641602(int32_t result, const Attributes &extraInfo) 686 [](int32_t result, const Attributes &extraInfo) {
687 EXPECT_EQ(result, HDF_FAILURE);
688 }
689 );
690
691 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
692 EXPECT_NE(mockHdi, nullptr);
693 EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _)).WillOnce(Return(HDF_FAILURE));
694
695 service.DelUser(testUserId, testAuthToken, testCallback);
696 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
697 service.DelUser(testUserId, testAuthToken, testCallback);
698 IpcCommon::DeleteAllPermission();
699 }
700
701 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelUser002, TestSize.Level0)
702 {
703 UserIdmService service(123123, true);
704 int32_t testUserId = 15486465;
705 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
706 sptr<IdmCallbackInterface> testCallback(nullptr);
707 service.DelUser(testUserId, testAuthToken, testCallback);
708 }
709
710 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelUser003, TestSize.Level0)
711 {
712 UserIdmService service(123123, true);
713 int32_t testUserId = 15486465;
714 std::vector<uint8_t> testAuthToken;
715 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
716 EXPECT_NE(testCallback, nullptr);
717 EXPECT_CALL(*testCallback, OnResult(_, _))
718 .WillOnce(
__anon62a1d9641702(int32_t result, const Attributes &extraInfo) 719 [](int32_t result, const Attributes &extraInfo) {
720 EXPECT_EQ(result, SUCCESS);
721 }
722 );
723
724 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
725 service.DelUser(testUserId, testAuthToken, testCallback);
726 IpcCommon::DeleteAllPermission();
727 }
728
729 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelUser004, TestSize.Level0)
730 {
731 UserIdmService service(123123, true);
732 int32_t testUserId = 15486465;
733 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
734 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
735 EXPECT_NE(testCallback, nullptr);
736 EXPECT_CALL(*testCallback, OnResult(_, _))
737 .WillOnce(
__anon62a1d9641802(int32_t result, const Attributes &extraInfo) 738 [](int32_t result, const Attributes &extraInfo) {
739 EXPECT_EQ(result, SUCCESS);
740 }
741 );
742
743 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
744 EXPECT_NE(mockHdi, nullptr);
745 EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _))
746 .WillOnce(
747 [](int32_t userId, const std::vector<uint8_t> &authToken, std::vector<HdiCredentialInfo> &deletedInfos,
__anon62a1d9641902(int32_t userId, const std::vector<uint8_t> &authToken, std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) 748 std::vector<uint8_t> &rootSecret) {
749 HdiCredentialInfo info = {};
750 info.authType = static_cast<HdiAuthType>(1);
751 info.credentialId = 10;
752 info.executorIndex = 20;
753 info.executorMatcher = 30;
754 info.executorSensorHint = 40;
755 info.templateId = 50;
756 deletedInfos.emplace_back(info);
757 return HDF_SUCCESS;
758 }
759 );
760
761 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
762 service.DelUser(testUserId, testAuthToken, testCallback);
763 IpcCommon::DeleteAllPermission();
764 }
765
766 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelCredential001, TestSize.Level0)
767 {
768 UserIdmService service(123123, true);
769 int32_t testUserId = 1548865;
770 uint64_t testCredentialId = 23424;
771 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
772
773 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
774 EXPECT_NE(testCallback, nullptr);
775 EXPECT_CALL(*testCallback, OnResult(_, _))
776 .Times(2)
777 .WillOnce(
__anon62a1d9641a02(int32_t result, const Attributes &extraInfo) 778 [](int32_t result, const Attributes &extraInfo) {
779 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
780 }
781 )
782 .WillOnce(
__anon62a1d9641b02(int32_t result, const Attributes &extraInfo) 783 [](int32_t result, const Attributes &extraInfo) {
784 EXPECT_EQ(result, HDF_FAILURE);
785 }
786 );
787
788 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
789 EXPECT_NE(mockHdi, nullptr);
790 EXPECT_CALL(*mockHdi, DeleteCredential(_, _, _, _)).WillOnce(Return(HDF_FAILURE));
791
792 service.DelCredential(testUserId, testCredentialId, testAuthToken, testCallback);
793 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
794 service.DelCredential(testUserId, testCredentialId, testAuthToken, testCallback);
795 IpcCommon::DeleteAllPermission();
796 }
797
798 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelCredential002, TestSize.Level0)
799 {
800 UserIdmService service(123123, true);
801 int32_t testUserId = 1548865;
802 uint64_t testCredentialId = 23424;
803 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
804 sptr<IdmCallbackInterface> testCallback(nullptr);
805 service.DelCredential(testUserId, testCredentialId, testAuthToken, testCallback);
806 }
807
808 HWTEST_F(UserIdmServiceTest, UserIdmServiceDelCredential003, TestSize.Level0)
809 {
810 UserIdmService service(123123, true);
811 int32_t testUserId = 1548865;
812 uint64_t testCredentialId = 23424;
813 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
814
815 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
816 EXPECT_NE(testCallback, nullptr);
817 EXPECT_CALL(*testCallback, OnResult(_, _))
818 .WillOnce(
__anon62a1d9641c02(int32_t result, const Attributes &extraInfo) 819 [](int32_t result, const Attributes &extraInfo) {
820 EXPECT_EQ(result, SUCCESS);
821 }
822 );
823
824 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
825 EXPECT_NE(mockHdi, nullptr);
826 EXPECT_CALL(*mockHdi, DeleteCredential(_, _, _, _))
827 .WillOnce(
__anon62a1d9641d02(int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, HdiCredentialInfo &info) 828 [](int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, HdiCredentialInfo &info) {
829 info.authType = static_cast<HdiAuthType>(1);
830 info.credentialId = 10;
831 info.executorIndex = 20;
832 info.executorMatcher = 30;
833 info.executorSensorHint = 40;
834 info.templateId = 50;
835 return HDF_SUCCESS;
836 }
837 );
838
839 IpcCommon::AddPermission(MANAGE_USER_IDM_PERMISSION);
840 service.DelCredential(testUserId, testCredentialId, testAuthToken, testCallback);
841 IpcCommon::DeleteAllPermission();
842 }
843
844 HWTEST_F(UserIdmServiceTest, UserIdmServiceTestDump, TestSize.Level0)
845 {
846 int testFd1 = -1;
847 int testFd2 = 1;
848 std::vector<std::u16string> testArgs;
849
850 UserIdmService service(123123, true);
851
852 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
853 EXPECT_NE(mockHdi, nullptr);
854 EXPECT_CALL(*mockHdi, GetUserInfo(_, _, _, _))
855 .Times(2)
856 .WillOnce(Return(HDF_FAILURE))
857 .WillOnce(
__anon62a1d9641e02(int32_t userId, uint64_t &secureUid, int32_t &pinSubType, std::vector<HdiEnrolledInfo> &infos) 858 [](int32_t userId, uint64_t &secureUid, int32_t &pinSubType, std::vector<HdiEnrolledInfo> &infos) {
859 HdiEnrolledInfo info = {
860 .enrolledId = 0,
861 .authType = static_cast<HdiAuthType>(1),
862 };
863 infos.push_back(info);
864 pinSubType = static_cast<HdiPinSubType>(10000);
865 secureUid = 4542;
866 return HDF_SUCCESS;
867 }
868 );
869
870 EXPECT_EQ(service.Dump(testFd1, testArgs), INVALID_PARAMETERS);
871 EXPECT_EQ(service.Dump(testFd2, testArgs), SUCCESS);
872 testArgs.push_back(u"-h");
873 EXPECT_EQ(service.Dump(testFd2, testArgs), SUCCESS);
874 testArgs.clear();
875 testArgs.push_back(u"-l");
876 EXPECT_EQ(service.Dump(testFd2, testArgs), GENERAL_ERROR);
877 EXPECT_EQ(service.Dump(testFd2, testArgs), SUCCESS);
878 testArgs.clear();
879 testArgs.push_back(u"-k");
880 EXPECT_EQ(service.Dump(testFd2, testArgs), GENERAL_ERROR);
881 }
882
883 HWTEST_F(UserIdmServiceTest, UserIdmServiceClearRedundancyCredential001, TestSize.Level0)
884 {
885 UserIdmService service(123123, true);
886 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
887 EXPECT_NE(testCallback, nullptr);
888 EXPECT_CALL(*testCallback, OnResult(_, _))
889 .Times(2)
890 .WillOnce(
__anon62a1d9641f02(int32_t result, const Attributes &extraInfo) 891 [](int32_t result, const Attributes &extraInfo) {
892 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
893 }
894 )
895 .WillOnce(
__anon62a1d9642002(int32_t result, const Attributes &extraInfo) 896 [](int32_t result, const Attributes &extraInfo) {
897 EXPECT_EQ(result, SUCCESS);
898 }
899 );
900
901 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
902 EXPECT_NE(mockHdi, nullptr);
903 EXPECT_CALL(*mockHdi, GetAllExtUserInfo(_)).WillOnce(Return(HDF_FAILURE));
904
905 service.ClearRedundancyCredential(testCallback);
906 IpcCommon::AddPermission(CLEAR_REDUNDANCY_PERMISSION);
907 service.ClearRedundancyCredential(testCallback);
908 IpcCommon::DeleteAllPermission();
909 }
910
911 HWTEST_F(UserIdmServiceTest, UserIdmServiceClearRedundancyCredential002, TestSize.Level0)
912 {
913 UserIdmService service(123123, true);
914 sptr<MockIdmCallback> testCallback(new (std::nothrow) MockIdmCallback());
915 EXPECT_NE(testCallback, nullptr);
916 EXPECT_CALL(*testCallback, OnResult(_, _))
917 .Times(2)
918 .WillOnce(
__anon62a1d9642102(int32_t result, const Attributes &extraInfo) 919 [](int32_t result, const Attributes &extraInfo) {
920 EXPECT_EQ(result, HDF_SUCCESS);
921 }
922 )
923 .WillOnce(
__anon62a1d9642202(int32_t result, const Attributes &extraInfo) 924 [](int32_t result, const Attributes &extraInfo) {
925 EXPECT_EQ(result, HDF_SUCCESS);
926 }
927 );
928
929 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
930 EXPECT_NE(mockHdi, nullptr);
931 EXPECT_CALL(*mockHdi, GetAllExtUserInfo(_))
932 .WillRepeatedly(
__anon62a1d9642302(std::vector<ExtUserInfo> &userInfos) 933 [](std::vector<ExtUserInfo> &userInfos) {
934 ExtUserInfo info = {
935 .userId = 100,
936 };
937 userInfos.push_back(info);
938 return HDF_SUCCESS;
939 }
940 );
941
942 EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _))
943 .Times(2)
944 .WillOnce(Return(HDF_FAILURE))
945 .WillOnce(
__anon62a1d9642402(int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) 946 [](int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) {
947 HdiCredentialInfo info = {};
948 info.authType = static_cast<HdiAuthType>(1);
949 info.credentialId = 10;
950 info.executorIndex = 20;
951 info.executorMatcher = 30;
952 info.executorSensorHint = 40;
953 info.templateId = 50;
954 deletedInfos.emplace_back(info);
955 return HDF_SUCCESS;
956 }
957 );
958
959 IpcCommon::AddPermission(CLEAR_REDUNDANCY_PERMISSION);
960 service.ClearRedundancyCredential(testCallback);
961 service.ClearRedundancyCredential(testCallback);
962 IpcCommon::DeleteAllPermission();
963 }
964 } // namespace UserAuth
965 } // namespace UserIam
966 } // namespace OHOS