1 /*
2 * Copyright (c) 2025 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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <cstdint>
20 #include <cstring>
21 #include <sys/time.h>
22
23 #include "cJSON.h"
24 #include "auth_hichain_id_service_mock.h"
25 #include "auth_identity_service_adapter.c"
26 #include "auth_log.h"
27 #include "softbus_adapter_json.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_error_code.h"
30
31 namespace OHOS {
32 using namespace testing;
33 using namespace testing::ext;
34
35 constexpr int32_t BUF_LEN = 10;
36
37 #define FIELD_CRED_TYPE "credType"
38 #define FIELD_DEVICE_ID "deviceId"
39 #define FIELD_USER_ID "userId"
40 #define FIELD_SUBJECT "subject"
41 #define FIELD_DEVICE_ID_HASH "deviceIdHash"
42
43 #define ACCOUNT_RELATED 1
44 #define ACCOUNT_UNRELATED 2
45 #define ACCOUNT_SHARE 3
46
47 #define SUBJECT_MASTER_CONTROLLER 1
48 #define SUBJECT_ACCESSORY_DEVICE 2
49
50 #define TEST_CREDID_INFO "123456789"
51 #define TEST_UDID_HASH "1122334455667788"
52 #define TEST_ACCOUNT_HASH "1122"
53 #define TEST_UDID "123456465421"
54
55 class AuthHichainIdServiceTest : public testing::Test {
56 public:
57 static void SetUpTestCase();
58 static void TearDownTestCase();
59 void SetUp();
60 void TearDown();
61 };
62
SetUpTestCase()63 void AuthHichainIdServiceTest::SetUpTestCase() {}
64
TearDownTestCase()65 void AuthHichainIdServiceTest::TearDownTestCase() {}
66
SetUp()67 void AuthHichainIdServiceTest::SetUp() {}
68
TearDown()69 void AuthHichainIdServiceTest::TearDown() {}
70
cleanCJSONMsgList(cJSON ** msgList,int index)71 void cleanCJSONMsgList(cJSON **msgList, int index)
72 {
73 for (int i = 0; i < index; i++) {
74 if (msgList[i] != nullptr) {
75 SoftBusFree(msgList[i]);
76 }
77 }
78 return;
79 }
80
TestAssembleCredInfo(uint8_t credType,uint8_t subject,const char * udidHash,const char * userId)81 static char *TestAssembleCredInfo(uint8_t credType, uint8_t subject, const char *udidHash, const char *userId)
82 {
83 JsonObj *json = JSON_CreateObject();
84 if (json == nullptr) {
85 AUTH_LOGE(AUTH_TEST, "create json fail");
86 return nullptr;
87 }
88 if (!JSON_AddInt32ToObject(json, FIELD_CRED_TYPE, credType) ||
89 !JSON_AddInt32ToObject(json, FIELD_SUBJECT, subject) ||
90 !JSON_AddStringToObject(json, FIELD_DEVICE_ID, udidHash) ||
91 !JSON_AddStringToObject(json, FIELD_USER_ID, userId)) {
92 AUTH_LOGE(AUTH_TEST, "add cred info fail");
93 JSON_Delete(json);
94 return nullptr;
95 }
96 char *msg = JSON_PrintUnformatted(json);
97 if (msg == nullptr) {
98 AUTH_LOGE(AUTH_TEST, "JSON_PrintUnformatted fail");
99 JSON_Delete(json);
100 return nullptr;
101 }
102 JSON_Delete(json);
103 return msg;
104 }
105
106 static CredChangeListener g_regListenerTest = {
107 .onCredAdd = nullptr,
108 .onCredDelete = nullptr,
109 .onCredUpdate = nullptr,
110 };
111
TestRegisterChangeListener(const char * appId,CredChangeListener * listener)112 static int32_t TestRegisterChangeListener(const char *appId, CredChangeListener *listener)
113 {
114 (void)appId;
115 AUTH_LOGI(AUTH_TEST, "********TestRegisterChangeListener enter");
116 g_regListenerTest.onCredAdd = listener->onCredAdd;
117 g_regListenerTest.onCredDelete = listener->onCredDelete;
118 g_regListenerTest.onCredUpdate = listener->onCredUpdate;
119 return SOFTBUS_OK;
120 }
121
TestUnRegisterChangeListener(const char * appId)122 static int32_t TestUnRegisterChangeListener(const char *appId)
123 {
124 (void)appId;
125 AUTH_LOGI(AUTH_TEST, "********TestUnRegisterChangeListener enter");
126 g_regListenerTest.onCredAdd = nullptr;
127 g_regListenerTest.onCredDelete = nullptr;
128 g_regListenerTest.onCredUpdate = nullptr;
129 return SOFTBUS_OK;
130 }
131
TestQueryCredentialByParams(int32_t osAccountId,const char * requestParams,char ** returnData)132 static int32_t TestQueryCredentialByParams(int32_t osAccountId, const char *requestParams, char **returnData)
133 {
134 AUTH_LOGI(AUTH_TEST, "********TestQueryCredentialByParams enter");
135 (void)requestParams;
136 (void)returnData;
137
138 if (osAccountId == 0) {
139 return SOFTBUS_INVALID_PARAM;
140 }
141 return SOFTBUS_OK;
142 }
143
144 /*
145 * @tc.name: ID_SERVICE_GENERATE_QUERY_PARAM_TEST_001
146 * @tc.desc: IdServiceGenerateQueryParam test
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_GENERATE_QUERY_PARAM_TEST_001, TestSize.Level1)
151 {
152 AuthHichainIdServiceInterfaceMock IdServiceMock;
153 char *param;
154 char udidHash[BUF_LEN] = { 0 };
155 char accountHash[BUF_LEN] = { 0 };
156 const char *data = "1234";
157 cJSON *msg[4] = { 0 };
158
159 for (int i = 0; i < 4; i++) {
160 msg[i] = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
161 if (msg[i] == nullptr) {
162 cleanCJSONMsgList(msg, i);
163 return;
164 }
165 }
166
167 EXPECT_CALL(IdServiceMock, cJSON_CreateObject).WillOnce(Return(nullptr)).WillOnce(Return(msg[0]))
168 .WillOnce(Return(msg[1])).WillOnce(Return(msg[2])).WillOnce(Return(msg[3]));
169 EXPECT_CALL(IdServiceMock, AddStringToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
170 EXPECT_CALL(IdServiceMock, AddNumberToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
171 EXPECT_CALL(IdServiceMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr)).WillRepeatedly(Return((char *)data));
172
173 param = IdServiceGenerateQueryParam(udidHash, accountHash, false);
174 EXPECT_EQ(param, nullptr);
175
176 param = IdServiceGenerateQueryParam(udidHash, accountHash, true);
177 EXPECT_EQ(param, nullptr);
178
179 param = IdServiceGenerateQueryParam(udidHash, accountHash, true);
180 EXPECT_EQ(param, nullptr);
181
182 param = IdServiceGenerateQueryParam(udidHash, accountHash, true);
183 EXPECT_EQ(param, nullptr);
184
185 param = IdServiceGenerateQueryParam(udidHash, accountHash, true);
186 EXPECT_NE(param, nullptr);
187 }
188
QueryCredentialByParamsTest(int32_t osAccountId,const char * requestParams,char ** returnData)189 int32_t QueryCredentialByParamsTest(int32_t osAccountId, const char *requestParams, char **returnData)
190 {
191 (void)requestParams;
192 (void)returnData;
193
194 if (osAccountId == 0) {
195 return SOFTBUS_INVALID_PARAM;
196 }
197
198 return SOFTBUS_OK;
199 }
200
201 /*
202 * @tc.name: ID_SERVICE_QUERY_CRED_TEST_001
203 * @tc.desc: IdServiceQueryCredential test
204 * @tc.type: FUNC
205 * @tc.require:
206 */
207 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_QUERY_CRED_TEST_001, TestSize.Level1)
208 {
209 AuthHichainIdServiceInterfaceMock IdServiceMock;
210 char udidHash[BUF_LEN] = { 0 };
211 char accountHash[BUF_LEN] = { 0 };
212 int32_t userId = 0;
213 char *credList = nullptr;
214 int32_t ret;
215 CredManager credManager;
216 cJSON *msg[2] = { 0 };
217
218 for (int i = 0; i < 2; i++) {
219 msg[i] = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
220 if (msg[i] == nullptr) {
221 cleanCJSONMsgList(msg, i);
222 return;
223 }
224 }
225
226 char *data = reinterpret_cast<char *>(SoftBusCalloc(sizeof(cJSON)));
227 if (data == nullptr) {
228 cleanCJSONMsgList(msg, 2);
229 return;
230 }
231
232 char *data1 = reinterpret_cast<char *>(SoftBusCalloc(sizeof(cJSON)));
233 if (data1 == nullptr) {
234 cleanCJSONMsgList(msg, 2);
235 SoftBusFree(data);
236 return;
237 }
238
239 EXPECT_CALL(IdServiceMock, cJSON_CreateObject).WillOnce(Return(msg[0])).WillOnce(Return(msg[1]));
240 EXPECT_CALL(IdServiceMock, AddStringToJsonObject).WillRepeatedly(Return(true));
241 EXPECT_CALL(IdServiceMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
242 EXPECT_CALL(IdServiceMock, cJSON_PrintUnformatted).WillOnce(Return(data)).WillOnce(Return(data1));
243
244 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillOnce(Return(SOFTBUS_INVALID_PARAM))
245 .WillRepeatedly(Return(SOFTBUS_OK));
246 credManager.queryCredentialByParams = QueryCredentialByParamsTest;
247 EXPECT_CALL(IdServiceMock, GetCredMgrInstance).WillRepeatedly(Return(&credManager));
248
249 ret = IdServiceQueryCredential(userId, udidHash, accountHash, false, &credList);
250 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_CRED_INSTANCE_FALI);
251
252 ret = IdServiceQueryCredential(userId, udidHash, accountHash, false, &credList);
253 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
254
255 userId = 1;
256 ret = IdServiceQueryCredential(userId, udidHash, accountHash, false, &credList);
257 EXPECT_EQ(ret, SOFTBUS_OK);
258 }
259
260 /*
261 * @tc.name: ID_SERVICE_GENERATE_AUTH_PARAM_001
262 * @tc.desc: IdServiceGenerateAuthParam test
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_GENERATE_AUTH_PARAM_001, TestSize.Level1)
267 {
268 AuthHichainIdServiceInterfaceMock IdServiceMock;
269 char *param;
270 const char *data = "1234";
271 HiChainAuthParam hiChainParam = {};
272
273 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
274 if (msg == nullptr) {
275 return;
276 }
277
278 cJSON *msg1 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
279 if (msg1 == nullptr) {
280 SoftBusFree(msg);
281 return;
282 }
283
284 cJSON *msg2 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
285 if (msg1 == nullptr) {
286 SoftBusFree(msg);
287 SoftBusFree(msg1);
288 return;
289 }
290
291 EXPECT_CALL(IdServiceMock, cJSON_CreateObject).WillOnce(Return(nullptr)).WillOnce(Return(msg))
292 .WillOnce(Return(msg1)).WillOnce(Return(msg2));
293 EXPECT_CALL(IdServiceMock, AddStringToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
294 EXPECT_CALL(IdServiceMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr)).WillRepeatedly(Return((char *)data));
295
296 param = IdServiceGenerateAuthParam(&hiChainParam);
297 EXPECT_EQ(param, nullptr);
298
299 param = IdServiceGenerateAuthParam(&hiChainParam);
300 EXPECT_EQ(param, nullptr);
301
302 param = IdServiceGenerateAuthParam(&hiChainParam);
303 EXPECT_EQ(param, nullptr);
304
305 param = IdServiceGenerateAuthParam(&hiChainParam);
306 EXPECT_NE(param, nullptr);
307 }
308
AuthCredentialTest(int32_t osAccountId,int64_t authReqId,const char * authParams,const DeviceAuthCallback * gaCallback)309 int32_t AuthCredentialTest(int32_t osAccountId, int64_t authReqId, const char *authParams,
310 const DeviceAuthCallback *gaCallback)
311 {
312 (void)osAccountId;
313 (void)authParams;
314 (void)gaCallback;
315
316 if (authReqId == 0) {
317 return SOFTBUS_INVALID_PARAM;
318 }
319
320 return SOFTBUS_OK;
321 }
322
323 /*
324 * @tc.name: ID_SERVICE_AUTH_CRED_001
325 * @tc.desc: IdServiceAuthCredential test
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_AUTH_CRED_001, TestSize.Level1)
330 {
331 AuthHichainIdServiceInterfaceMock IdServiceMock;
332 int32_t userId = 0;
333 int64_t authReqId = 0;
334 const char *authParams = "abcd";
335 DeviceAuthCallback cb;
336 int32_t ret;
337 CredAuthManager authMgr;
338
339 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillOnce(Return(SOFTBUS_INVALID_PARAM))
340 .WillRepeatedly(Return(SOFTBUS_OK));
341 authMgr.authCredential = AuthCredentialTest;
342 EXPECT_CALL(IdServiceMock, GetCredAuthInstance).WillRepeatedly(Return(&authMgr));
343
344 ret = IdServiceAuthCredential(userId, authReqId, authParams, &cb);
345 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_CRED_INSTANCE_FALI);
346
347 ret = IdServiceAuthCredential(userId, authReqId, authParams, &cb);
348 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
349
350 authReqId = 1;
351 ret = IdServiceAuthCredential(userId, authReqId, authParams, &cb);
352 EXPECT_EQ(ret, SOFTBUS_OK);
353 }
354
ProcessCredDataTest(int64_t authReqId,const uint8_t * data,uint32_t dataLen,const DeviceAuthCallback * gaCallback)355 int32_t ProcessCredDataTest(int64_t authReqId, const uint8_t *data, uint32_t dataLen,
356 const DeviceAuthCallback *gaCallback)
357 {
358 (void)data;
359 (void)dataLen;
360 (void)gaCallback;
361
362 if (authReqId == 0) {
363 return SOFTBUS_INVALID_PARAM;
364 }
365
366 return SOFTBUS_OK;
367 }
368
369 /*
370 * @tc.name: ID_SERVICE_PROCESS_CRED_DATA_001
371 * @tc.desc: IdServiceProcessCredData test
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_PROCESS_CRED_DATA_001, TestSize.Level1)
376 {
377 AuthHichainIdServiceInterfaceMock IdServiceMock;
378 const char *data = "1234";
379 int64_t authReqId = 0;
380 DeviceAuthCallback cb;
381 int32_t ret;
382 CredAuthManager authMgr;
383
384 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillOnce(Return(SOFTBUS_INVALID_PARAM))
385 .WillRepeatedly(Return(SOFTBUS_OK));
386
387 authMgr.processCredData = ProcessCredDataTest;
388 EXPECT_CALL(IdServiceMock, GetCredAuthInstance).WillRepeatedly(Return(&authMgr));
389
390 ret = IdServiceProcessCredData(authReqId, (unsigned char *)data, strlen(data), &cb);
391 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_CRED_INSTANCE_FALI);
392
393 ret = IdServiceProcessCredData(authReqId, (unsigned char *)data, strlen(data), &cb);
394 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
395
396 authReqId = 1;
397 ret = IdServiceProcessCredData(authReqId, (unsigned char *)data, strlen(data), &cb);
398 EXPECT_EQ(ret, SOFTBUS_OK);
399 }
400
401 int32_t g_count;
DestroyInfoTest(char ** returnData)402 void DestroyInfoTest(char **returnData)
403 {
404 g_count++;
405 return;
406 }
407
408 /*
409 * @tc.name: ID_SERVICE_INIT_SERVICE_TEST_001
410 * @tc.desc: init service test
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_INIT_SERVICE_TEST_001, TestSize.Level1)
415 {
416 AuthHichainIdServiceInterfaceMock IdServiceMock;
417 char *msg = nullptr;
418 CredManager g_testCredMgr = {
419 .registerChangeListener = TestRegisterChangeListener,
420 .queryCredentialByParams = TestQueryCredentialByParams,
421 .unregisterChangeListener = TestUnRegisterChangeListener,
422 };
423
424 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
425 EXPECT_CALL(IdServiceMock, GetCredMgrInstance).WillRepeatedly(Return(&g_testCredMgr));
426 int32_t ret = IdServiceRegCredMgr();
427 if (g_regListenerTest.onCredAdd != nullptr) {
428 g_regListenerTest.onCredAdd(nullptr, nullptr);
429 }
430 if (g_regListenerTest.onCredUpdate != nullptr) {
431 g_regListenerTest.onCredUpdate(nullptr, nullptr);
432 }
433 if (g_regListenerTest.onCredDelete != nullptr) {
434 g_regListenerTest.onCredDelete(nullptr, nullptr);
435 }
436 msg = TestAssembleCredInfo(ACCOUNT_SHARE, SUBJECT_MASTER_CONTROLLER, TEST_UDID_HASH, TEST_ACCOUNT_HASH);
437 char localUdid[UDID_BUF_LEN] = { 0 };
438 EXPECT_EQ(strcpy_s(localUdid, UDID_BUF_LEN, TEST_UDID), EOK);
439 EXPECT_CALL(IdServiceMock, LnnGetLocalStrInfo)
440 .WillRepeatedly(DoAll(SetArgPointee<1>(*localUdid), Return(SOFTBUS_OK)));
441 EXPECT_CALL(IdServiceMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
442 EXPECT_CALL(IdServiceMock, LnnInsertSpecificTrustedDevInfo).WillRepeatedly(Return(SOFTBUS_OK));
443 EXPECT_CALL(IdServiceMock, LnnHbOnTrustedRelationIncreased).WillRepeatedly(Return());
444 EXPECT_CALL(IdServiceMock, LnnDeleteSpecificTrustedDevInfo).WillRepeatedly(Return(SOFTBUS_OK));
445 EXPECT_CALL(IdServiceMock, LnnHbOnTrustedRelationReduced).WillRepeatedly(Return());
446 if (msg != nullptr && g_regListenerTest.onCredAdd != nullptr && g_regListenerTest.onCredDelete != nullptr) {
447 g_regListenerTest.onCredAdd(TEST_CREDID_INFO, msg);
448 g_regListenerTest.onCredDelete(TEST_CREDID_INFO, msg);
449 }
450 SoftBusFree(msg);
451 IdServiceUnRegCredMgr();
452 EXPECT_EQ(ret, SOFTBUS_OK);
453 }
454
455 /*
456 * @tc.name: ID_SERVICE_INIT_SERVICE_TEST_002
457 * @tc.desc: init service test
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_INIT_SERVICE_TEST_002, TestSize.Level1)
462 {
463 AuthHichainIdServiceInterfaceMock IdServiceMock;
464 char *msg = nullptr;
465 CredManager g_testCredMgr = {
466 .registerChangeListener = TestRegisterChangeListener,
467 .queryCredentialByParams = TestQueryCredentialByParams,
468 .unregisterChangeListener = TestUnRegisterChangeListener,
469 };
470
471 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
472 EXPECT_CALL(IdServiceMock, GetCredMgrInstance).WillRepeatedly(Return(&g_testCredMgr));
473 int32_t ret = IdServiceRegCredMgr();
474 msg = TestAssembleCredInfo(ACCOUNT_SHARE, SUBJECT_ACCESSORY_DEVICE, TEST_UDID_HASH, TEST_ACCOUNT_HASH);
475 EXPECT_CALL(IdServiceMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
476 EXPECT_CALL(IdServiceMock, LnnDeleteSpecificTrustedDevInfo).WillRepeatedly(Return(SOFTBUS_OK));
477 EXPECT_CALL(IdServiceMock, LnnHbOnTrustedRelationReduced).WillRepeatedly(Return());
478 if (msg != nullptr && g_regListenerTest.onCredAdd != nullptr && g_regListenerTest.onCredDelete != nullptr) {
479 g_regListenerTest.onCredAdd(TEST_CREDID_INFO, msg);
480 g_regListenerTest.onCredDelete(TEST_CREDID_INFO, msg);
481 }
482 SoftBusFree(msg);
483 IdServiceUnRegCredMgr();
484 EXPECT_EQ(ret, SOFTBUS_OK);
485 }
486
487 /*
488 * @tc.name: ID_SERVICE_INIT_SERVICE_TEST_003
489 * @tc.desc: init service test
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_INIT_SERVICE_TEST_003, TestSize.Level1)
494 {
495 AuthHichainIdServiceInterfaceMock IdServiceMock;
496 char *msg1 = nullptr;
497 char *msg2 = nullptr;
498 CredManager g_testCredMgr = {
499 .registerChangeListener = TestRegisterChangeListener,
500 .queryCredentialByParams = TestQueryCredentialByParams,
501 .unregisterChangeListener = TestUnRegisterChangeListener,
502 };
503
504 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
505 EXPECT_CALL(IdServiceMock, GetCredMgrInstance).WillRepeatedly(Return(&g_testCredMgr));
506 int32_t ret = IdServiceRegCredMgr();
507 msg1 = TestAssembleCredInfo(ACCOUNT_SHARE, SUBJECT_MASTER_CONTROLLER, TEST_UDID_HASH, TEST_ACCOUNT_HASH);
508 msg2 = TestAssembleCredInfo(ACCOUNT_SHARE, SUBJECT_ACCESSORY_DEVICE, TEST_UDID_HASH, TEST_ACCOUNT_HASH);
509 char localUdid[UDID_BUF_LEN] = { 0 };
510 EXPECT_EQ(strcpy_s(localUdid, UDID_BUF_LEN, TEST_UDID), EOK);
511 EXPECT_CALL(IdServiceMock, LnnGetLocalStrInfo)
512 .WillRepeatedly(DoAll(SetArgPointee<1>(*localUdid), Return(SOFTBUS_OK)));
513 EXPECT_CALL(IdServiceMock, LnnGetLocalNumInfo)
514 .WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
515 .WillRepeatedly(Return(SOFTBUS_OK));
516 EXPECT_CALL(IdServiceMock, LnnInsertSpecificTrustedDevInfo).WillRepeatedly(Return(SOFTBUS_OK));
517 EXPECT_CALL(IdServiceMock, LnnHbOnTrustedRelationIncreased).WillRepeatedly(Return());
518 if (msg1 != nullptr && msg2 != NULL && g_regListenerTest.onCredAdd != nullptr &&
519 g_regListenerTest.onCredUpdate != nullptr) {
520 g_regListenerTest.onCredAdd(TEST_CREDID_INFO, msg1);
521 g_regListenerTest.onCredUpdate(TEST_CREDID_INFO, msg2);
522 }
523 SoftBusFree(msg1);
524 SoftBusFree(msg2);
525 IdServiceUnRegCredMgr();
526 EXPECT_EQ(ret, SOFTBUS_OK);
527 }
528
529 /*
530 * @tc.name: ID_SERVICE_DESTROY_CREDLIST_001
531 * @tc.desc: IdServiceDestroyCredentialList test
532 * @tc.type: FUNC
533 * @tc.require:
534 */
535 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_DESTROY_CREDLIST_001, TestSize.Level1)
536 {
537 AuthHichainIdServiceInterfaceMock IdServiceMock;
538 CredManager credManager;
539 char *data = nullptr;
540
541 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillOnce(Return(SOFTBUS_INVALID_PARAM))
542 .WillRepeatedly(Return(SOFTBUS_OK));
543 credManager.destroyInfo = DestroyInfoTest;
544 EXPECT_CALL(IdServiceMock, GetCredMgrInstance).WillRepeatedly(Return(&credManager));
545
546 IdServiceDestroyCredentialList(nullptr);
547 EXPECT_EQ(g_count, 0);
548
549 IdServiceDestroyCredentialList(&data);
550 EXPECT_EQ(g_count, 0);
551
552 IdServiceDestroyCredentialList(&data);
553 EXPECT_EQ(g_count, 1);
554 }
555
556 char g_credInfo[100];
QueryCredInfoByCredId(int32_t userId,const char * credId,char ** credInfo)557 int32_t QueryCredInfoByCredId(int32_t userId, const char *credId, char **credInfo)
558 {
559 if (userId == 0) {
560 return SOFTBUS_INVALID_PARAM;
561 }
562
563 *credInfo = g_credInfo;
564 return SOFTBUS_OK;
565 }
566
567 /*
568 * @tc.name: ID_SERVICE_GET_CREDID_FROM_LIST_001
569 * @tc.desc: IdServiceGetCredIdFromCredList test
570 * @tc.type: FUNC
571 * @tc.require:
572 */
573 HWTEST_F(AuthHichainIdServiceTest, ID_SERVICE_GET_CREDID_FROM_LIST_001, TestSize.Level1)
574 {
575 AuthHichainIdServiceInterfaceMock IdServiceMock;
576 CredManager credManager;
577 char *credId = nullptr;
578 int32_t userId = 0;
579
580 EXPECT_CALL(IdServiceMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
581 credManager.destroyInfo = DestroyInfoTest;
582 credManager.queryCredInfoByCredId = QueryCredInfoByCredId;
583 EXPECT_CALL(IdServiceMock, GetCredMgrInstance).WillRepeatedly(Return(&credManager));
584
585 credId = IdServiceGetCredIdFromCredList(userId, nullptr);
586 EXPECT_EQ(credId, nullptr);
587
588 credId = IdServiceGetCredIdFromCredList(userId, "[]");
589 EXPECT_EQ(credId, nullptr);
590
591 credId = IdServiceGetCredIdFromCredList(userId, "[\"123\", \"456\"]");
592 EXPECT_EQ(credId, nullptr);
593
594 userId = 1;
595
596 memset_s(g_credInfo, sizeof(g_credInfo), 0, sizeof(g_credInfo));
597 strcpy_s(g_credInfo, sizeof(g_credInfo), "{\"credOwner\":\"DM\"}");
598 credId = IdServiceGetCredIdFromCredList(userId, "[\"123\", \"456\"]");
599 EXPECT_EQ(credId, nullptr);
600
601 memset_s(g_credInfo, sizeof(g_credInfo), 0, sizeof(g_credInfo));
602 strcpy_s(g_credInfo, sizeof(g_credInfo), "{\"credType\":2}");
603 credId = IdServiceGetCredIdFromCredList(userId, "[\"123\", \"456\"]");
604 EXPECT_EQ(credId, nullptr);
605
606 memset_s(g_credInfo, sizeof(g_credInfo), 0, sizeof(g_credInfo));
607 strcpy_s(g_credInfo, sizeof(g_credInfo), "{\"credType\":2,\"authorizedScope\":2}");
608 credId = IdServiceGetCredIdFromCredList(userId, "[\"123\", \"456\"]");
609 EXPECT_NE(credId, nullptr);
610
611 SoftBusFree(credId);
612 }
613 } // namespace OHOS