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_client_test.h"
17
18 #include "iam_ptr.h"
19 #include "mock_ipc_client_utils.h"
20 #include "mock_remote_object.h"
21 #include "mock_user_idm_client_callback.h"
22 #include "mock_user_idm_service.h"
23 #include "user_idm_client.h"
24
25 namespace OHOS {
26 namespace UserIam {
27 namespace UserAuth {
28 using namespace testing;
29 using namespace testing::ext;
30
SetUpTestCase()31 void UserIdmClientTest::SetUpTestCase()
32 {
33 }
34
TearDownTestCase()35 void UserIdmClientTest::TearDownTestCase()
36 {
37 }
38
SetUp()39 void UserIdmClientTest::SetUp()
40 {
41 }
42
TearDown()43 void UserIdmClientTest::TearDown()
44 {
45 }
46
47 HWTEST_F(UserIdmClientTest, UserIdmClientOpenSession001, TestSize.Level0)
48 {
49 int32_t testUserId = 21200;
50
51 IpcClientUtils::ResetObj();
52 std::vector<uint8_t> challenge = UserIdmClient::GetInstance().OpenSession(testUserId);
53 EXPECT_TRUE(challenge.empty());
54 }
55
56 HWTEST_F(UserIdmClientTest, UserIdmClientOpenSession002, TestSize.Level0)
57 {
58 int32_t testUserId = 21200;
59 std::vector<uint8_t> testChallenge = {1, 3, 4, 7};
60
61 auto service = Common::MakeShared<MockUserIdmService>();
62 EXPECT_NE(service, nullptr);
63 EXPECT_CALL(*service, OpenSession(_, _)).Times(1);
64 ON_CALL(*service, OpenSession)
65 .WillByDefault(
__anonac41bd630102(int32_t userId, std::vector<uint8_t> &challenge) 66 [&testUserId, &testChallenge](int32_t userId, std::vector<uint8_t> &challenge) {
67 EXPECT_EQ(userId, testUserId);
68 challenge = testChallenge;
69 return SUCCESS;
70 }
71 );
72 sptr<MockRemoteObject> obj = new MockRemoteObject();
73 EXPECT_NE(obj, nullptr);
74 IpcClientUtils::SetObj(obj);
75 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
76 ON_CALL(*obj, SendRequest)
__anonac41bd630202(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 77 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
78 service->OnRemoteRequest(code, data, reply, option);
79 return OHOS::NO_ERROR;
80 });
81
82 std::vector<uint8_t> challenge = UserIdmClient::GetInstance().OpenSession(testUserId);
83 EXPECT_THAT(challenge, ElementsAreArray(testChallenge));
84 IpcClientUtils::ResetObj();
85 }
86
87 HWTEST_F(UserIdmClientTest, UserIdmClientCloseSession001, TestSize.Level0)
88 {
89 int32_t testUserId = 200;
90
91 IpcClientUtils::ResetObj();
92 UserIdmClient::GetInstance().CloseSession(testUserId);
93 }
94
95 HWTEST_F(UserIdmClientTest, UserIdmClientCloseSession002, TestSize.Level0)
96 {
97 int32_t testUserId = 200;
98
99 auto service = Common::MakeShared<MockUserIdmService>();
100 EXPECT_NE(service, nullptr);
101 EXPECT_CALL(*service, CloseSession(_)).Times(1);
102 ON_CALL(*service, CloseSession)
103 .WillByDefault(
__anonac41bd630302(int32_t userId) 104 [&testUserId](int32_t userId) {
105 EXPECT_EQ(userId, testUserId);
106 return;
107 }
108 );
109 sptr<MockRemoteObject> obj = new MockRemoteObject();
110 EXPECT_NE(obj, nullptr);
111 IpcClientUtils::SetObj(obj);
112 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
113 ON_CALL(*obj, SendRequest)
__anonac41bd630402(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 114 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
115 service->OnRemoteRequest(code, data, reply, option);
116 return OHOS::NO_ERROR;
117 });
118
119 UserIdmClient::GetInstance().CloseSession(testUserId);
120 IpcClientUtils::ResetObj();
121 }
122
123 HWTEST_F(UserIdmClientTest, UserIdmClientAddCredential001, TestSize.Level0)
124 {
125 int32_t testUserId = 200;
126 CredentialParameters testPara = {};
127 std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
128 UserIdmClient::GetInstance().AddCredential(testUserId, testPara, testCallback);
129
130 testCallback = Common::MakeShared<MockUserIdmClientCallback>();
131 EXPECT_NE(testCallback, nullptr);
132 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
133 IpcClientUtils::ResetObj();
134 UserIdmClient::GetInstance().AddCredential(testUserId, testPara, testCallback);
135 }
136
137 HWTEST_F(UserIdmClientTest, UserIdmClientAddCredential002, TestSize.Level0)
138 {
139 int32_t testUserId = 200;
140 CredentialParameters testPara = {};
141 testPara.authType = FACE;
142 testPara.pinType = std::nullopt;
143 testPara.token = {1, 4, 7, 0};
144 auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
145 EXPECT_NE(testCallback, nullptr);
146 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
147
148 auto service = Common::MakeShared<MockUserIdmService>();
149 EXPECT_NE(service, nullptr);
150 EXPECT_CALL(*service, AddCredential(_, _, _, _)).Times(1);
151 ON_CALL(*service, AddCredential)
152 .WillByDefault(
153 [&testUserId, &testPara](int32_t userId, const UserIdmInterface::CredentialPara &credPara,
__anonac41bd630502(int32_t userId, const UserIdmInterface::CredentialPara &credPara, const sptr<IdmCallbackInterface> &callback, bool isUpdate) 154 const sptr<IdmCallbackInterface> &callback, bool isUpdate) {
155 EXPECT_EQ(userId, testUserId);
156 EXPECT_EQ(credPara.authType, testPara.authType);
157 EXPECT_THAT(credPara.token, ElementsAreArray(testPara.token));
158 EXPECT_EQ(isUpdate, false);
159 if (callback != nullptr) {
160 Attributes extraInfo;
161 callback->OnResult(SUCCESS, extraInfo);
162 }
163 }
164 );
165 sptr<MockRemoteObject> obj = new MockRemoteObject();
166 EXPECT_NE(obj, nullptr);
167 IpcClientUtils::SetObj(obj);
168 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
169 ON_CALL(*obj, SendRequest)
__anonac41bd630602(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 170 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
171 service->OnRemoteRequest(code, data, reply, option);
172 return OHOS::NO_ERROR;
173 });
174
175 UserIdmClient::GetInstance().AddCredential(testUserId, testPara, testCallback);
176 IpcClientUtils::ResetObj();
177 }
178
179 HWTEST_F(UserIdmClientTest, UserIdmClientUpdateCredential001, TestSize.Level0)
180 {
181 int32_t testUserId = 200;
182 CredentialParameters testPara = {};
183 std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
184 UserIdmClient::GetInstance().UpdateCredential(testUserId, testPara, testCallback);
185
186 testCallback = Common::MakeShared<MockUserIdmClientCallback>();
187 EXPECT_NE(testCallback, nullptr);
188 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
189 IpcClientUtils::ResetObj();
190 UserIdmClient::GetInstance().UpdateCredential(testUserId, testPara, testCallback);
191 }
192
193 HWTEST_F(UserIdmClientTest, UserIdmClientUpdateCredential002, TestSize.Level0)
194 {
195 int32_t testUserId = 200;
196 CredentialParameters testPara = {};
197 testPara.authType = PIN;
198 testPara.pinType = PIN_SIX;
199 testPara.token = {1, 4, 7, 0};
200 auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
201 EXPECT_NE(testCallback, nullptr);
202 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
203
204 auto service = Common::MakeShared<MockUserIdmService>();
205 EXPECT_NE(service, nullptr);
206 EXPECT_CALL(*service, UpdateCredential(_, _, _)).Times(1);
207 ON_CALL(*service, UpdateCredential)
208 .WillByDefault(
209 [&testUserId, &testPara](int32_t userId, const UserIdmInterface::CredentialPara &credPara,
__anonac41bd630702(int32_t userId, const UserIdmInterface::CredentialPara &credPara, const sptr<IdmCallbackInterface> &callback) 210 const sptr<IdmCallbackInterface> &callback) {
211 EXPECT_EQ(userId, testUserId);
212 EXPECT_EQ(credPara.authType, testPara.authType);
213 EXPECT_TRUE(testPara.pinType.has_value());
214 EXPECT_EQ(credPara.pinType, testPara.pinType.value());
215 EXPECT_THAT(credPara.token, ElementsAreArray(testPara.token));
216 if (callback != nullptr) {
217 Attributes extraInfo;
218 callback->OnResult(SUCCESS, extraInfo);
219 }
220 }
221 );
222 sptr<MockRemoteObject> obj = new MockRemoteObject();
223 EXPECT_NE(obj, nullptr);
224 IpcClientUtils::SetObj(obj);
225 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
226 ON_CALL(*obj, SendRequest)
__anonac41bd630802(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 227 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
228 service->OnRemoteRequest(code, data, reply, option);
229 return OHOS::NO_ERROR;
230 });
231
232 UserIdmClient::GetInstance().UpdateCredential(testUserId, testPara, testCallback);
233 IpcClientUtils::ResetObj();
234 }
235
236 HWTEST_F(UserIdmClientTest, UserIdmClientCancel001, TestSize.Level0)
237 {
238 int32_t testUserId = 200;
239
240 IpcClientUtils::ResetObj();
241 int32_t ret = UserIdmClient::GetInstance().Cancel(testUserId);
242 EXPECT_EQ(ret, GENERAL_ERROR);
243 }
244
245 HWTEST_F(UserIdmClientTest, UserIdmClientCancel002, TestSize.Level0)
246 {
247 int32_t testUserId = 200;
248
249 auto service = Common::MakeShared<MockUserIdmService>();
250 EXPECT_NE(service, nullptr);
251 EXPECT_CALL(*service, Cancel(_)).Times(1);
252 ON_CALL(*service, Cancel)
253 .WillByDefault(
__anonac41bd630902(int32_t userId) 254 [&testUserId](int32_t userId) {
255 EXPECT_EQ(userId, testUserId);
256 return SUCCESS;
257 }
258 );
259 sptr<MockRemoteObject> obj = new MockRemoteObject();
260 EXPECT_NE(obj, nullptr);
261 IpcClientUtils::SetObj(obj);
262 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
263 ON_CALL(*obj, SendRequest)
__anonac41bd630a02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 264 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
265 service->OnRemoteRequest(code, data, reply, option);
266 return OHOS::NO_ERROR;
267 });
268
269 int32_t ret = UserIdmClient::GetInstance().Cancel(testUserId);
270 EXPECT_EQ(ret, SUCCESS);
271 IpcClientUtils::ResetObj();
272 }
273
274 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteCredential001, TestSize.Level0)
275 {
276 int32_t testUserId = 200;
277 uint64_t testCredentialId = 111;
278 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
279 std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
280 UserIdmClient::GetInstance().DeleteCredential(testUserId, testCredentialId, testAuthToken, testCallback);
281
282 IpcClientUtils::ResetObj();
283 testCallback = Common::MakeShared<MockUserIdmClientCallback>();
284 EXPECT_NE(testCallback, nullptr);
285 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
286 UserIdmClient::GetInstance().DeleteCredential(testUserId, testCredentialId, testAuthToken, testCallback);
287 }
288
289 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteCredential002, TestSize.Level0)
290 {
291 int32_t testUserId = 200;
292 uint64_t testCredentialId = 111;
293 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
294 auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
295 EXPECT_NE(testCallback, nullptr);
296 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
297
298 auto service = Common::MakeShared<MockUserIdmService>();
299 EXPECT_NE(service, nullptr);
300 EXPECT_CALL(*service, DelCredential(_, _, _, _)).Times(1);
301 ON_CALL(*service, DelCredential)
302 .WillByDefault(
303 [&testUserId, &testCredentialId, &testAuthToken](int32_t userId, uint64_t credentialId,
__anonac41bd630b02(int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, const sptr<IdmCallbackInterface> &callback) 304 const std::vector<uint8_t> &authToken, const sptr<IdmCallbackInterface> &callback) {
305 EXPECT_EQ(userId, testUserId);
306 EXPECT_EQ(credentialId, testCredentialId);
307 EXPECT_THAT(authToken, ElementsAreArray(testAuthToken));
308 if (callback != nullptr) {
309 Attributes extraInfo;
310 callback->OnResult(SUCCESS, extraInfo);
311 }
312 }
313 );
314 sptr<MockRemoteObject> obj = new MockRemoteObject();
315 EXPECT_NE(obj, nullptr);
316 IpcClientUtils::SetObj(obj);
317 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
318 ON_CALL(*obj, SendRequest)
__anonac41bd630c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 319 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
320 service->OnRemoteRequest(code, data, reply, option);
321 return OHOS::NO_ERROR;
322 });
323
324 UserIdmClient::GetInstance().DeleteCredential(testUserId, testCredentialId, testAuthToken, testCallback);
325 IpcClientUtils::ResetObj();
326 }
327
328 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteUser001, TestSize.Level0)
329 {
330 int32_t testUserId = 200;
331 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
332 std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
333 UserIdmClient::GetInstance().DeleteUser(testUserId, testAuthToken, testCallback);
334
335 IpcClientUtils::ResetObj();
336 testCallback = Common::MakeShared<MockUserIdmClientCallback>();
337 EXPECT_NE(testCallback, nullptr);
338 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
339 UserIdmClient::GetInstance().DeleteUser(testUserId, testAuthToken, testCallback);
340 }
341
342 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteUser002, TestSize.Level0)
343 {
344 int32_t testUserId = 200;
345 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
346 auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
347 EXPECT_NE(testCallback, nullptr);
348 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
349
350 auto service = Common::MakeShared<MockUserIdmService>();
351 EXPECT_NE(service, nullptr);
352 EXPECT_CALL(*service, DelUser(_, _, _)).Times(1);
353 ON_CALL(*service, DelUser)
354 .WillByDefault(
355 [&testUserId, &testAuthToken](int32_t userId, const std::vector<uint8_t> authToken,
__anonac41bd630d02(int32_t userId, const std::vector<uint8_t> authToken, const sptr<IdmCallbackInterface> &callback) 356 const sptr<IdmCallbackInterface> &callback) {
357 EXPECT_EQ(userId, testUserId);
358 EXPECT_THAT(authToken, ElementsAreArray(testAuthToken));
359 if (callback != nullptr) {
360 Attributes extraInfo;
361 callback->OnResult(SUCCESS, extraInfo);
362 }
363 }
364 );
365 sptr<MockRemoteObject> obj = new MockRemoteObject();
366 EXPECT_NE(obj, nullptr);
367 IpcClientUtils::SetObj(obj);
368 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
369 ON_CALL(*obj, SendRequest)
__anonac41bd630e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 370 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
371 service->OnRemoteRequest(code, data, reply, option);
372 return OHOS::NO_ERROR;
373 });
374
375 UserIdmClient::GetInstance().DeleteUser(testUserId, testAuthToken, testCallback);
376 IpcClientUtils::ResetObj();
377 }
378
379 HWTEST_F(UserIdmClientTest, UserIdmClientEraseUser001, TestSize.Level0)
380 {
381 int32_t testUserId = 200;
382 std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
383 int32_t ret = UserIdmClient::GetInstance().EraseUser(testUserId, testCallback);
384 EXPECT_EQ(ret, GENERAL_ERROR);
385
386 IpcClientUtils::ResetObj();
387 testCallback = Common::MakeShared<MockUserIdmClientCallback>();
388 EXPECT_NE(testCallback, nullptr);
389 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
390 ret = UserIdmClient::GetInstance().EraseUser(testUserId, testCallback);
391 EXPECT_EQ(ret, GENERAL_ERROR);
392 }
393
394 HWTEST_F(UserIdmClientTest, UserIdmClientEraseUser002, TestSize.Level0)
395 {
396 int32_t testUserId = 200;
397 auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
398 EXPECT_NE(testCallback, nullptr);
399 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
400
401 auto service = Common::MakeShared<MockUserIdmService>();
402 EXPECT_NE(service, nullptr);
403 EXPECT_CALL(*service, EnforceDelUser(_, _)).Times(1);
404 ON_CALL(*service, EnforceDelUser)
405 .WillByDefault(
__anonac41bd630f02(int32_t userId, const sptr<IdmCallbackInterface> &callback) 406 [&testUserId](int32_t userId, const sptr<IdmCallbackInterface> &callback) {
407 EXPECT_EQ(userId, testUserId);
408 if (callback != nullptr) {
409 Attributes extraInfo;
410 callback->OnResult(SUCCESS, extraInfo);
411 }
412 return SUCCESS;
413 }
414 );
415 sptr<MockRemoteObject> obj = new MockRemoteObject();
416 EXPECT_NE(obj, nullptr);
417 IpcClientUtils::SetObj(obj);
418 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
419 ON_CALL(*obj, SendRequest)
__anonac41bd631002(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 420 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
421 service->OnRemoteRequest(code, data, reply, option);
422 return OHOS::NO_ERROR;
423 });
424
425 int32_t ret = UserIdmClient::GetInstance().EraseUser(testUserId, testCallback);
426 EXPECT_EQ(ret, SUCCESS);
427 IpcClientUtils::ResetObj();
428 }
429
430 HWTEST_F(UserIdmClientTest, UserIdmClientGetCredentialInfo001, TestSize.Level0)
431 {
432 int32_t testUserId = 200;
433 AuthType testAuthType = PIN;
434 std::shared_ptr<MockGetCredentialInfoCallback> testCallback = nullptr;
435 int32_t ret = UserIdmClient::GetInstance().GetCredentialInfo(testUserId, testAuthType, testCallback);
436 EXPECT_EQ(ret, GENERAL_ERROR);
437
438 IpcClientUtils::ResetObj();
439 testCallback = Common::MakeShared<MockGetCredentialInfoCallback>();
440 EXPECT_NE(testCallback, nullptr);
441 EXPECT_CALL(*testCallback, OnCredentialInfo(_)).Times(1);
442 ret = UserIdmClient::GetInstance().GetCredentialInfo(testUserId, testAuthType, testCallback);
443 EXPECT_EQ(ret, GENERAL_ERROR);
444 }
445
446 HWTEST_F(UserIdmClientTest, UserIdmClientGetCredentialInfo002, TestSize.Level0)
447 {
448 int32_t testUserId = 200;
449 AuthType testAuthType = PIN;
450 auto testCallback = Common::MakeShared<MockGetCredentialInfoCallback>();
451 EXPECT_NE(testCallback, nullptr);
452 EXPECT_CALL(*testCallback, OnCredentialInfo(_)).Times(1);
453
454 auto service = Common::MakeShared<MockUserIdmService>();
455 EXPECT_NE(service, nullptr);
456 EXPECT_CALL(*service, GetCredentialInfo(_, _, _)).Times(1);
457 ON_CALL(*service, GetCredentialInfo)
458 .WillByDefault(
459 [&testUserId, &testAuthType](int32_t userId, AuthType authType,
__anonac41bd631102(int32_t userId, AuthType authType, const sptr<IdmGetCredInfoCallbackInterface> &callback) 460 const sptr<IdmGetCredInfoCallbackInterface> &callback) {
461 EXPECT_EQ(userId, testUserId);
462 EXPECT_EQ(authType, testAuthType);
463 if (callback != nullptr) {
464 callback->OnCredentialInfos({}, std::nullopt);
465 }
466 return SUCCESS;
467 }
468 );
469 sptr<MockRemoteObject> obj = new MockRemoteObject();
470 EXPECT_NE(obj, nullptr);
471 IpcClientUtils::SetObj(obj);
472 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
473 ON_CALL(*obj, SendRequest)
__anonac41bd631202(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 474 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
475 service->OnRemoteRequest(code, data, reply, option);
476 return OHOS::NO_ERROR;
477 });
478
479 int32_t ret = UserIdmClient::GetInstance().GetCredentialInfo(testUserId, testAuthType, testCallback);
480 EXPECT_EQ(ret, SUCCESS);
481 IpcClientUtils::ResetObj();
482 }
483
484 HWTEST_F(UserIdmClientTest, UserIdmClientGetSecUserInfo001, TestSize.Level0)
485 {
486 int32_t testUserId = 200;
487 std::shared_ptr<MockGetSecUserInfoCallback> testCallback = nullptr;
488 int32_t ret = UserIdmClient::GetInstance().GetSecUserInfo(testUserId, testCallback);
489 EXPECT_EQ(ret, GENERAL_ERROR);
490
491 IpcClientUtils::ResetObj();
492 testCallback = Common::MakeShared<MockGetSecUserInfoCallback>();
493 EXPECT_NE(testCallback, nullptr);
494 EXPECT_CALL(*testCallback, OnSecUserInfo(_)).Times(1);
495 ret = UserIdmClient::GetInstance().GetSecUserInfo(testUserId, testCallback);
496 EXPECT_EQ(ret, GENERAL_ERROR);
497 }
498
499 HWTEST_F(UserIdmClientTest, UserIdmClientGetSecUserInfo002, TestSize.Level0)
500 {
501 int32_t testUserId = 200;
502 auto testCallback = Common::MakeShared<MockGetSecUserInfoCallback>();
503 EXPECT_NE(testCallback, nullptr);
504
505 auto service = Common::MakeShared<MockUserIdmService>();
506 EXPECT_NE(service, nullptr);
507 EXPECT_CALL(*service, GetSecInfo(_, _)).Times(1);
508 ON_CALL(*service, GetSecInfo)
509 .WillByDefault(
__anonac41bd631302(int32_t userId, const sptr<IdmGetSecureUserInfoCallbackInterface> &callback) 510 [&testUserId](int32_t userId, const sptr<IdmGetSecureUserInfoCallbackInterface> &callback) {
511 EXPECT_EQ(userId, testUserId);
512 EXPECT_NE(callback, nullptr);
513 return SUCCESS;
514 }
515 );
516 sptr<MockRemoteObject> obj = new MockRemoteObject();
517 EXPECT_NE(obj, nullptr);
518 IpcClientUtils::SetObj(obj);
519 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
520 ON_CALL(*obj, SendRequest)
__anonac41bd631402(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 521 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
522 service->OnRemoteRequest(code, data, reply, option);
523 return OHOS::NO_ERROR;
524 });
525
526 int32_t ret = UserIdmClient::GetInstance().GetSecUserInfo(testUserId, testCallback);
527 EXPECT_EQ(ret, SUCCESS);
528 IpcClientUtils::ResetObj();
529 }
530 } // namespace UserAuth
531 } // namespace UserIam
532 } // namespace OHOS