1 /*
2 * Copyright (c) 2022-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 "UTTest_hichain_connector.h"
17
18 #include <cstdlib>
19 #include <ctime>
20 #include <functional>
21 #include <securec.h>
22
23 #include "device_manager_service_listener.h"
24 #include "dm_anonymous.h"
25 #include "dm_constants.h"
26 #include "dm_credential_manager.h"
27 #include "dm_log.h"
28 #include "dm_random.h"
29 #include "parameter.h"
30
31 namespace OHOS {
32 namespace DistributedHardware {
SetUp()33 void HichainConnectorTest::SetUp()
34 {
35 }
TearDown()36 void HichainConnectorTest::TearDown()
37 {
38 }
SetUpTestCase()39 void HichainConnectorTest::SetUpTestCase()
40 {
41 }
TearDownTestCase()42 void HichainConnectorTest::TearDownTestCase()
43 {
44 }
45
46 class HiChainConnectorCallbackTest : public IHiChainConnectorCallback {
47 public:
HiChainConnectorCallbackTest()48 HiChainConnectorCallbackTest() {}
~HiChainConnectorCallbackTest()49 virtual ~HiChainConnectorCallbackTest() {}
OnGroupCreated(int64_t requestId,const std::string & groupId)50 void OnGroupCreated(int64_t requestId, const std::string &groupId) override
51 {
52 (void)requestId;
53 (void)groupId;
54 }
OnMemberJoin(int64_t requestId,int32_t status,int32_t operationCode)55 void OnMemberJoin(int64_t requestId, int32_t status, int32_t operationCode) override
56 {
57 (void)requestId;
58 (void)status;
59 (void)operationCode;
60 }
GetConnectAddr(std::string deviceId)61 std::string GetConnectAddr(std::string deviceId)
62 {
63 return "";
64 }
GetPinCode(std::string & code)65 int32_t GetPinCode(std::string &code)
66 {
67 code = "123456";
68 return DM_OK;
69 }
70 };
71
72 namespace {
73 /**
74 * @tc.name: CreateGroup_001
75 * @tc.desc: Set the deviceGroupManager_ pointer to CreateGroup to NULlptr and return ERR_DM_INPUT_PARA_INVALID
76 * @tc.type: FUNC
77 * @tc.require: AR000GHSJK
78 */
79 HWTEST_F(HichainConnectorTest, CreateGroup_001, testing::ext::TestSize.Level1)
80 {
81 int64_t requestId = 123456;
82 std::string groupName = "dfggg";
83 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
84 hiChainConnector->deviceGroupManager_ = nullptr;
85 int ret = hiChainConnector->CreateGroup(requestId, groupName);
86 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
87 }
88
89 /**
90 * @tc.name: CreateGroup_002
91 * @tc.desc: Set CreateGroup to the correct process and return DM_OK
92 * @tc.type: FUNC
93 * @tc.require: AR000GHSJK
94 */
95 HWTEST_F(HichainConnectorTest, CreateGroup_002, testing::ext::TestSize.Level1)
96 {
97 int64_t requestId = 123456;
98 std::string groupName = "uuiioo";
99 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
100 int ret = hiChainConnector->CreateGroup(requestId, groupName);
101 EXPECT_EQ(ret, ERR_DM_CREATE_GROUP_FAILED);
102 }
103
104 /**
105 * @tc.name: CreateGroup_003
106 * @tc.desc: Set deviceGroupManager_ is nullptr return ERR_DM_INPUT_PARA_INVALID
107 * @tc.type: FUNC
108 * @tc.require: AR000GHSJK
109 */
110 HWTEST_F(HichainConnectorTest, CreateGroup_003, testing::ext::TestSize.Level1)
111 {
112 int64_t requestId = 159357;
113 int32_t authType = 1;
114 std::string userId = "userIdTest";
115 JsonObject jsonOutObj;
116 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
117 hiChainConnector->deviceGroupManager_ = nullptr;
118 int32_t ret = hiChainConnector->CreateGroup(requestId, authType, userId, jsonOutObj);
119 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
120 }
121
122 /**
123 * @tc.name: IsGroupInfoInvalid_001
124 * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is not GROUP_VISIBILITY_PUBLIC.
125 Group.return true
126 * @tc.type: FUNC
127 * @tc.require: AR000GHSJK
128 */
129
130 HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_001, testing::ext::TestSize.Level1)
131 {
132 GroupInfo group;
133 group.groupName = "dkdkkdkdk";
134 group.groupId = 1;
135 group.groupOwner = "ohos.distributedhardware.devicemanager";
136 group.groupType = 7;
137 group.groupVisibility = 1;
138 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
139 bool ret = hiChainConnector->IsGroupInfoInvalid(group);
140 EXPECT_EQ(ret, false);
141 }
142
143 /**
144 * @tc.name: IsGroupInfoInvalid_002
145 * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is GROUP_VISIBILITY_PUBLIC,
146 Grou. groupOwner is not equal to DM_PKG_NAME. The value is true
147 * @tc.type: FUNC
148 * @tc.require: AR000GHSJK
149 */
150 HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_002, testing::ext::TestSize.Level1)
151 {
152 GroupInfo group;
153 group.groupName = "test";
154 group.groupId = 1;
155 group.groupOwner = "ohos.disware";
156 group.groupType = 1;
157 group.groupVisibility = -1;
158 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
159 bool ret = hiChainConnector->IsGroupInfoInvalid(group);
160 EXPECT_EQ(ret, true);
161 }
162
163 /**
164 * @tc.name: DelMemberFromGroup_001
165 * @tc.desc:set groupId, deviceId null and return DM_OK
166 * @tc.type: FUNC
167 * @tc.require: AR000GHSJK
168 */
169 HWTEST_F(HichainConnectorTest, DelMemberFromGroup_001, testing::ext::TestSize.Level1)
170 {
171 std::string groupId;
172 std::string deviceId;
173 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
174 int ret = hiChainConnector->DelMemberFromGroup(groupId, deviceId);
175 EXPECT_NE(ret, -1);
176 }
177
178 /**
179 * @tc.name: DelMemberFromGroup_002
180 * @tc.desc: The groupId "34451"; The deviceId = "123"; Can be deleted correctly
181 * @tc.type: FUNC
182 * @tc.require: AR000GHSJK
183 */
184 HWTEST_F(HichainConnectorTest, DelMemberFromGroup_002, testing::ext::TestSize.Level1)
185 {
186 std::string groupId = "34451";
187 std::string deviceId = "123";
188 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
189 int ret = hiChainConnector->DelMemberFromGroup(groupId, deviceId);
190 EXPECT_NE(ret, -1);
191 }
192
193 /**
194 * @tc.name: GenRequestId_001
195 * @tc.desc:Call the GenRequestId function
196 * @tc.type: FUNC
197 * @tc.require: AR000GHSJK
198 */
199 HWTEST_F(HichainConnectorTest, GenRequestId_001, testing::ext::TestSize.Level1)
200 {
201 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
202 int ret = hiChainConnector->GenRequestId();
203 ASSERT_NE(ret, 0);
204 }
205
206 /**
207 * @tc.name: from_json_001
208 * @tc.desc: Pass in arguments to the from_JSON function and convert it to the correct value
209 * @tc.type: FUNC
210 * @tc.require: AR000GHSJK
211 */
212 HWTEST_F(HichainConnectorTest, from_json_001, testing::ext::TestSize.Level1)
213 {
214 GroupInfo groupInfo;
215 groupInfo.groupName = "aaaa";
216 groupInfo.groupId = "345678";
217 groupInfo.groupOwner = "lllll";
218 groupInfo.groupType = 5;
219 groupInfo.groupVisibility = 5;
220 JsonObject jsonObject;
221 jsonObject[FIELD_GROUP_NAME] = groupInfo.groupName;
222 jsonObject[FIELD_GROUP_ID] = groupInfo.groupId;
223 jsonObject[FIELD_GROUP_OWNER] = groupInfo.groupOwner;
224 jsonObject[FIELD_GROUP_TYPE] = groupInfo.groupType;
225 jsonObject[FIELD_GROUP_VISIBILITY] = groupInfo.groupVisibility;
226 GroupInfo groupInfo1;
227 FromJson(jsonObject, groupInfo1);
228 EXPECT_EQ(groupInfo1.groupName, "aaaa");
229 EXPECT_EQ(groupInfo1.groupId, "345678");
230 EXPECT_EQ(groupInfo1.groupOwner, "lllll");
231 EXPECT_EQ(groupInfo1.groupType, 5);
232 EXPECT_EQ(groupInfo1.groupVisibility, 5);
233 }
234
235 /**
236 * @tc.name: from_json_002
237 * @tc.desc: Pass in arguments to the from_JSON function and convert it to the correct value
238 * @tc.type: FUNC
239 * @tc.require: AR000GHSJK
240 */
241 HWTEST_F(HichainConnectorTest, from_json_002, testing::ext::TestSize.Level1)
242 {
243 GroupInfo groupInfo;
244 groupInfo.userId = "test";
245 groupInfo.groupName = "test";
246 JsonObject jsonObject;
247 jsonObject[FIELD_GROUP_NAME] = 0;
248 jsonObject[FIELD_GROUP_ID] = 0;
249 jsonObject[FIELD_GROUP_OWNER] = 0;
250 jsonObject[FIELD_GROUP_TYPE] = "test";
251 jsonObject[FIELD_GROUP_VISIBILITY] = "test";
252 jsonObject[FIELD_USER_ID] = "userId";
253 FromJson(jsonObject, groupInfo);
254 EXPECT_EQ(groupInfo.userId, "userId");
255
256 jsonObject[FIELD_USER_ID] = "0";
257 jsonObject.Erase(FIELD_GROUP_NAME);
258 jsonObject.Erase(FIELD_GROUP_ID);
259 jsonObject.Erase(FIELD_GROUP_OWNER);
260 jsonObject.Erase(FIELD_GROUP_TYPE);
261 jsonObject.Erase(FIELD_GROUP_VISIBILITY);
262 GroupInfo groupInfo1;
263 jsonObject[FIELD_GROUP_NAME] = "test";
264 FromJson(jsonObject, groupInfo1);
265 EXPECT_EQ(groupInfo1.groupName, "test");
266 }
267
268 /**
269 * @tc.name: HiChainConnector_001
270 * @tc.desc: Returns a new pointer to the HiChainConnector constructor new
271 * @tc.type: FUNC
272 * @tc.require: AR000GHSJK
273 */
274 HWTEST_F(HichainConnectorTest, HiChainConnector_001, testing::ext::TestSize.Level1)
275 {
276 std::shared_ptr<HiChainConnector> m_HiChainConnector = std::make_shared<HiChainConnector>();
277 ASSERT_NE(m_HiChainConnector, nullptr);
278 }
279
280 /**
281 * @tc.name: HiChainConnector_002
282 * @tc.desc: Give the HiChainConnector constructor new a new pointer and delete it
283 * @tc.type: FUNC
284 * @tc.require: AR000GHSJK
285 */
286 HWTEST_F(HichainConnectorTest, HiChainConnector_002, testing::ext::TestSize.Level1)
287 {
288 std::shared_ptr<HiChainConnector> m_HiChainConnector = std::make_shared<HiChainConnector>();
289 m_HiChainConnector.reset();
290 EXPECT_EQ(m_HiChainConnector, nullptr);
291 }
292
293 /**
294 * @tc.name:RegisterHiChainCallback_001
295 * @tc.desc: Call the RegisterHiChainCallback function with a return value of DM_OK
296 * @tc.type: FUNC
297 * @tc.require: AR000GHSJK
298 */
299 HWTEST_F(HichainConnectorTest, RegisterHiChainCallback_001, testing::ext::TestSize.Level1)
300 {
301 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
302 int ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
303 EXPECT_EQ(ret, DM_OK);
304 }
305
306 /**
307 * @tc.name: AddMember_001
308 * @tc.desc: set deviceGroupManager_ = nullptr;
309 * @tc.type: FUNC
310 * @tc.require: AR000GHSJK
311 */
312 HWTEST_F(HichainConnectorTest, AddMember_001, testing::ext::TestSize.Level1)
313 {
314 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
315 hiChainConnector->deviceGroupManager_ = nullptr;
316 std::string deviceId;
317 std::string connectInfo;
318 int ret = hiChainConnector->AddMember(deviceId, connectInfo);
319 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
320 }
321
322 /**
323 * @tc.name: AddMember_002
324 * @tc.desc: set deviceId and connectInfo = null;
325 * @tc.type: FUNC
326 * @tc.require: AR000GHSJK
327 */
328 HWTEST_F(HichainConnectorTest, AddMember_002, testing::ext::TestSize.Level1)
329 {
330 std::string deviceId;
331 std::string connectInfo;
332 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
333 int ret = hiChainConnector->AddMember(deviceId, connectInfo);
334 EXPECT_EQ(ret, ERR_DM_FAILED);
335 }
336
337 /**
338 * @tc.name: AddMember_003
339 * @tc.desc: set deviceId and connectInfo = null;
340 * @tc.type: FUNC
341 * @tc.require: AR000GHSJK
342 */
343 HWTEST_F(HichainConnectorTest, AddMember_003, testing::ext::TestSize.Level1)
344 {
345 std::string deviceId = "123456";
346 std::string connectInfo = "dkdkk";
347 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
348 int ret = hiChainConnector->AddMember(deviceId, connectInfo);
349 ASSERT_EQ(ret, ERR_DM_FAILED);
350 }
351
352 /**
353 * @tc.name: AddMember_004
354 * @tc.desc: set deviceId and connectInfo = null;
355 * @tc.type: FUNC
356 * @tc.require: AR000GHSJK
357 */
358 HWTEST_F(HichainConnectorTest, AddMember_004, testing::ext::TestSize.Level1)
359 {
360 std::string deviceId = "deviceIdTest";
361 std::string connectInfo = R"(
362 {
363 "DEVICEID" : "deviceId",
364 "pinCode" : 1,
365 "groupId" : "groupId",
366 "REQUESTID" : "requestId",
367 "GROUPNAME" : "groupName"
368 }
369 )";
370 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
371 int32_t ret = hiChainConnector->AddMember(deviceId, connectInfo);
372 EXPECT_EQ(ret, ERR_DM_FAILED);
373 }
374
375 /**
376 * @tc.name: onRequest_001
377 * @tc.desc:set operationCode != GroupOperationCode::MEMBER_JOIN(3); return nullptr;
378 * @tc.require: AR000GHSJK
379 */
380 HWTEST_F(HichainConnectorTest, onRequest_001, testing::ext::TestSize.Level1)
381 {
382 int64_t requestId = 2;
383 int32_t operationCode = 2;
384 char *reqParams;
385 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
386 char *ret = hiChainConnector->onRequest(requestId, operationCode, reqParams);
387 EXPECT_EQ(ret, nullptr);
388 }
389
390 /**
391 * @tc.name: onRequest_002
392 * @tc.desc: operationCode = GroupOperationCode::MEMBER_JOIN(3)/hiChainConnectorCallback_ is nullptr; return nullptr;
393 * @tc.require: AR000GHSJK
394 */
395 HWTEST_F(HichainConnectorTest, onRequest_002, testing::ext::TestSize.Level1)
396 {
397 int64_t requestId = 2;
398 int32_t operationCode = 3;
399 char *reqParams;
400 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
401 hiChainConnector->hiChainConnectorCallback_ = nullptr;
402 char *ret = hiChainConnector->onRequest(requestId, operationCode, reqParams);
403 EXPECT_EQ(ret, nullptr);
404 }
405
406 /**
407 * @tc.name: onRequest_003
408 * @tc.desc: Test the onRequest method of HiChainConnector to ensure it handles different
409 * return values from GetPinCode correctly.
410 * @tc.require: AR000GHSJK
411 */
412 HWTEST_F(HichainConnectorTest, onRequest_003, testing::ext::TestSize.Level1)
413 {
414 int64_t requestId = 2;
415 int32_t operationCode = 3;
416 char *reqParams = nullptr;
417 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
418 std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
419 hiChainConnector->hiChainConnectorCallback_ = mockCallback;
420 EXPECT_CALL(*mockCallback, GetPinCode(testing::_))
421 .Times(1)
422 .WillOnce(testing::Return(ERR_DM_FAILED));
423 char *ret1 = hiChainConnector->onRequest(requestId, operationCode, reqParams);
424 EXPECT_NE(ret1, nullptr);
425 if (ret1 != nullptr) {
426 free(ret1);
427 ret1 = nullptr;
428 }
429
430 EXPECT_CALL(*mockCallback, GetPinCode(testing::_))
431 .Times(1)
432 .WillOnce(testing::Return(DM_OK));
433 char *ret2 = hiChainConnector->onRequest(requestId, operationCode, reqParams);
434 EXPECT_NE(ret2, nullptr);
435 if (ret2 != nullptr) {
436 free(ret2);
437 ret2 = nullptr;
438 }
439 }
440
441 /**
442 * @tc.name: GetConnectPara_001
443 * @tc.desc: Test GetConnectPara method when hiChainConnectorCallback_ is set to nullptr,
444 * ensuring it returns an empty string.
445 * @tc.type: FUNC
446 * @tc.require: AR000GHSJK
447 */
448 HWTEST_F(HichainConnectorTest, GetConnectPara_001, testing::ext::TestSize.Level1)
449 {
450 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
451 hiChainConnector->hiChainConnectorCallback_ = nullptr;
452 std::string deviceId = "12345";
453 std::string reqDeviceId = "12345";
454 std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
455 EXPECT_EQ(ret, "");
456 }
457
458 /**
459 * @tc.name: GetConnectPara_002
460 * @tc.desc: Test GetConnectPara method with an empty deviceId to ensure JSON parsing fails
461 * and returns an empty string.
462 * @tc.type: FUNC
463 * @tc.require: AR000GHSJK
464 */
465 HWTEST_F(HichainConnectorTest, GetConnectPara_002, testing::ext::TestSize.Level1)
466 {
467 std::string deviceId;
468 std::string reqDeviceId = "12345";
469 std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
470 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
471 hiChainConnector->hiChainConnectorCallback_ = mockCallback;
472 EXPECT_CALL(*mockCallback, GetConnectAddr(testing::_))
473 .Times(1)
474 .WillOnce(testing::Return(R"({"key": "value"})"));
475 std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
476 EXPECT_NE(ret, "");
477 }
478
479 /**
480 * @tc.name: GetConnectPara_003
481 * @tc.desc: Test GetConnectPara method with invalid JSON returned by hiChainConnectorCallback_
482 * to ensure it returns an empty string.
483 * @tc.type: FUNC
484 * @tc.require: AR000GHSJK
485 */
486 HWTEST_F(HichainConnectorTest, GetConnectPara_003, testing::ext::TestSize.Level1)
487 {
488 std::string deviceId;
489 std::string reqDeviceId = "12345";
490 std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
491 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
492 hiChainConnector->hiChainConnectorCallback_ = mockCallback;
493 EXPECT_CALL(*mockCallback, GetConnectAddr(testing::_))
494 .Times(1)
495 .WillOnce(testing::Return("invalid json"));
496 std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
497 EXPECT_EQ(ret, "invalid json");
498 }
499
500 /**
501 * @tc.name: DeleteGroup_001
502 * @tc.desc: set groupId = "34567", and return ERR_DM_FAILED
503 * @tc.type: FUNC
504 * @tc.require: AR000GHSJK
505 */
506 HWTEST_F(HichainConnectorTest, DeleteGroup_001, testing::ext::TestSize.Level1)
507 {
508 std::string groupId = "34567";
509 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
510 int ret = hiChainConnector->DeleteGroup(groupId);
511 EXPECT_EQ(ret, ERR_DM_FAILED);
512 }
513
514 /**
515 * @tc.name: GetRelatedGroups_001
516 * @tc.desc: set DeviceId 123 groupList null and return ERR_DM_FAILED
517 * @tc.type: FUNC
518 * @tc.require: AR000GHSJK
519 */
520 HWTEST_F(HichainConnectorTest, GetRelatedGroups_001, testing::ext::TestSize.Level1)
521 {
522 std::string deviceId = "123";
523 std::vector<GroupInfo> groupList;
524 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
525 int ret = hiChainConnector->GetRelatedGroups(deviceId, groupList);
526 EXPECT_EQ(ret, ERR_DM_FAILED);
527 }
528
529 /**
530 * @tc.name: GetRelatedGroupsExt_001
531 * @tc.desc: set DeviceId = 12345,groupList null and return ERR_DM_FAILED
532 * @tc.type: FUNC
533 * @tc.require: AR000GHSJK
534 */
535 HWTEST_F(HichainConnectorTest, GetRelatedGroupsExt_001, testing::ext::TestSize.Level1)
536 {
537 std::string deviceId = "12345";
538 std::vector<GroupInfo> groupList;
539 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
540 int ret = hiChainConnector->GetRelatedGroupsExt(deviceId, groupList);
541 EXPECT_EQ(ret, ERR_DM_FAILED);
542 }
543
544 /**
545 * @tc.name: SyncGroups_001
546 * @tc.desc: set deviceId = "34567", and return DM_OK
547 * @tc.type: FUNC
548 * @tc.require: AR000GHSJK
549 */
550 HWTEST_F(HichainConnectorTest, SyncGroups_001, testing::ext::TestSize.Level1)
551 {
552 std::string deviceId = "34567";
553 std::vector<std::string> remoteGroupIdList;
554 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
555 int ret = hiChainConnector->SyncGroups(deviceId, remoteGroupIdList);
556 EXPECT_EQ(ret, DM_OK);
557 }
558
559 /**
560 * @tc.name: GetSyncGroupList_001
561 * @tc.desc: set groupList null, and return ERR_DM_FAILED
562 * @tc.type: FUNC
563 * @tc.require: AR000GHSJK
564 */
565 HWTEST_F(HichainConnectorTest, GetSyncGroupList_001, testing::ext::TestSize.Level1)
566 {
567 std::vector<GroupInfo> groupList;
568 std::vector<std::string> syncGroupList;
569 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
570 int ret = hiChainConnector->GetSyncGroupList(groupList, syncGroupList);
571 EXPECT_EQ(ret, ERR_DM_FAILED);
572 }
573
574 /**
575 * @tc.name: GetSyncGroupList_002
576 * @tc.desc: set groupList not null, and return DM_OK
577 * @tc.type: FUNC
578 * @tc.require: AR000GHSJK
579 */
580 HWTEST_F(HichainConnectorTest, GetSyncGroupList_002, testing::ext::TestSize.Level1)
581 {
582 std::vector<GroupInfo> groupList;
583 GroupInfo groupList1;
584 groupList1.groupName = "groupName";
585 groupList1.groupId = 1;
586 groupList1.groupOwner = "ohos.distributedhardware.devicemanager";
587 groupList1.groupType = 7;
588 groupList1.groupVisibility = 1;
589 groupList.push_back(groupList1);
590 GroupInfo groupList2;
591 groupList2.groupName = "hichainconnector";
592 groupList2.groupId = "123456";
593 groupList2.groupOwner = "doftbus";
594 groupList2.groupType = 1;
595 groupList2.groupVisibility = 2;
596 groupList.push_back(groupList2);
597 std::vector<std::string> syncGroupList;
598 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
599 int ret = hiChainConnector->GetSyncGroupList(groupList, syncGroupList);
600 EXPECT_EQ(ret, DM_OK);
601 }
602
603 /**
604 * @tc.name: IsGroupCreated_001
605 * @tc.desc: return false
606 * @tc.type: FUNC
607 * @tc.require: AR000GHSJK
608 */
609 HWTEST_F(HichainConnectorTest, IsGroupCreated_001, testing::ext::TestSize.Level1)
610 {
611 std::string groupName = "groupNameTest";
612 GroupInfo groupInfo;
613 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
614 bool ret = hiChainConnector->IsGroupCreated(groupName, groupInfo);
615 EXPECT_EQ(ret, false);
616 }
617
618 /**
619 * @tc.name: IsRedundanceGroup_001
620 * @tc.desc: return false
621 * @tc.type: FUNC
622 * @tc.require: AR000GHSJK
623 */
624 HWTEST_F(HichainConnectorTest, IsRedundanceGroup_001, testing::ext::TestSize.Level1)
625 {
626 const std::string userId = "userIdTest";
627 int32_t authType = 1;
628 std::vector<GroupInfo> groupList;
629 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
630 bool ret = hiChainConnector->IsRedundanceGroup(userId, authType, groupList);
631 EXPECT_EQ(ret, false);
632 }
633
634 /**
635 * @tc.name: onFinish_001
636 * @tc.desc: return DM_OK
637 * @tc.type: FUNC
638 * @tc.require: AR000GHSJK
639 */
640 HWTEST_F(HichainConnectorTest, onFinish_001, testing::ext::TestSize.Level1)
641 {
642 int64_t requestId = 1;
643 int operationCode = GroupOperationCode::MEMBER_JOIN;
644 const char *returnData = "returnDataTest";
645 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
646 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
647
648 hiChainConnector->onFinish(requestId, operationCode, returnData);
649
650 operationCode = GroupOperationCode::GROUP_CREATE;
651 hiChainConnector->onFinish(requestId, operationCode, returnData);
652
653 operationCode = GroupOperationCode::MEMBER_DELETE;
654 hiChainConnector->onFinish(requestId, operationCode, returnData);
655
656 operationCode = GroupOperationCode::GROUP_DISBAND;
657 hiChainConnector->onFinish(requestId, operationCode, returnData);
658 EXPECT_EQ(ret, DM_OK);
659 }
660
661 /**
662 * @tc.name: onFinish_002
663 * @tc.desc: return DM_OK
664 * @tc.type: FUNC
665 * @tc.require: AR000GHSJK
666 */
667 HWTEST_F(HichainConnectorTest, onFinish_002, testing::ext::TestSize.Level1)
668 {
669 int64_t requestId = 1;
670 int operationCode = GroupOperationCode::MEMBER_JOIN;
671 const char *returnData = "returnDataTest";
672 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
673 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
674 EXPECT_EQ(ret, DM_OK);
675 ret = hiChainConnector->UnRegisterHiChainCallback();
676 EXPECT_EQ(ret, DM_OK);
677
678 hiChainConnector->onFinish(requestId, operationCode, returnData);
679
680 operationCode = GroupOperationCode::GROUP_CREATE;
681 hiChainConnector->onFinish(requestId, operationCode, returnData);
682
683 hiChainConnector->networkStyle_ = 1;
684 hiChainConnector->hiChainResCallback_ = nullptr;
685 hiChainConnector->onFinish(requestId, operationCode, returnData);
686
687 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
688 std::shared_ptr<HiChainConnector> hiChainConn = std::make_shared<HiChainConnector>();
689 hiChainConnector->hiChainResCallback_ = std::make_shared<DmCredentialManager>(hiChainConn, listener);
690 hiChainConnector->onFinish(requestId, operationCode, returnData);
691
692 operationCode = GroupOperationCode::GROUP_DISBAND;
693 hiChainConnector->onFinish(requestId, operationCode, returnData);
694
695 hiChainConnector->hiChainResCallback_ = nullptr;
696 hiChainConnector->onFinish(requestId, operationCode, returnData);
697
698 EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
699 }
700
701 /**
702 * @tc.name: onError_001
703 * @tc.desc: return DM_OK
704 * @tc.type: FUNC
705 * @tc.require: AR000GHSJK
706 */
707 HWTEST_F(HichainConnectorTest, onError_001, testing::ext::TestSize.Level1)
708 {
709 int64_t requestId = 1;
710 int operationCode = GroupOperationCode::MEMBER_JOIN;
711 int errorCode = 1;
712 const char *errorReturn = "errorReturnTest";
713 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
714 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
715 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
716
717 operationCode = GroupOperationCode::GROUP_CREATE;
718 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
719
720 operationCode = GroupOperationCode::MEMBER_DELETE;
721 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
722
723 operationCode = GroupOperationCode::GROUP_DISBAND;
724 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
725 EXPECT_EQ(ret, DM_OK);
726 }
727
728 /**
729 * @tc.name: onError_002
730 * @tc.desc: return DM_OK
731 * @tc.type: FUNC
732 * @tc.require: AR000GHSJK
733 */
734 HWTEST_F(HichainConnectorTest, onError_002, testing::ext::TestSize.Level1)
735 {
736 int64_t requestId = 1;
737 int operationCode = GroupOperationCode::MEMBER_JOIN;
738 int errorCode = 1;
739 const char *errorReturn = "errorReturnTest";
740 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
741 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
742 EXPECT_EQ(ret, DM_OK);
743 ret = hiChainConnector->UnRegisterHiChainCallback();
744 EXPECT_EQ(ret, DM_OK);
745 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
746
747 operationCode = GroupOperationCode::GROUP_CREATE;
748 hiChainConnector->networkStyle_ = 0;
749 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
750
751 hiChainConnector->networkStyle_ = 1;
752 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
753
754 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
755 std::shared_ptr<HiChainConnector> hiChainConn = std::make_shared<HiChainConnector>();
756 hiChainConnector->hiChainResCallback_ = std::make_shared<DmCredentialManager>(hiChainConn, listener);
757 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
758
759 operationCode = GroupOperationCode::GROUP_DISBAND;
760 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
761
762 hiChainConnector->hiChainResCallback_ = nullptr;
763 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
764 EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
765 }
766
767 /**
768 * @tc.name: DeleteGroup_002
769 * @tc.desc: return ERR_DM_FAILED
770 * @tc.type: FUNC
771 * @tc.require: AR000GHSJK
772 */
773 HWTEST_F(HichainConnectorTest, DeleteGroup_002, testing::ext::TestSize.Level1)
774 {
775 const int32_t userId = 1;
776 std::string groupId = "groupIdTest";
777 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
778 int32_t ret = hiChainConnector->DeleteGroup(userId, groupId);
779 EXPECT_EQ(ret, ERR_DM_FAILED);
780 }
781
782 /**
783 * @tc.name: DeleteGroup_003
784 * @tc.desc: return ERR_DM_FAILED
785 * @tc.type: FUNC
786 * @tc.require: AR000GHSJK
787 */
788 HWTEST_F(HichainConnectorTest, DeleteGroup_003, testing::ext::TestSize.Level1)
789 {
790 int64_t requestId = 1;
791 std::string userId = "userIdTest";
792 const int32_t authType = 1;
793 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
794 hiChainConnector->DeleteRedundanceGroup(userId);
795 int32_t ret = hiChainConnector->DeleteGroup(requestId, userId, authType);
796 EXPECT_EQ(ret, ERR_DM_FAILED);
797 }
798
799 /**
800 * @tc.name: RegisterHiChainGroupCallback_001
801 * @tc.desc: return DM_OK
802 * @tc.type: FUNC
803 * @tc.require: AR000GHSJK
804 */
805 HWTEST_F(HichainConnectorTest, RegisterHiChainGroupCallback_001, testing::ext::TestSize.Level1)
806 {
807 std::shared_ptr<IDmGroupResCallback> callback = nullptr;
808 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
809 int32_t ret = hiChainConnector->RegisterHiChainGroupCallback(callback);
810 EXPECT_EQ(ret, DM_OK);
811 }
812
813 /**
814 * @tc.name: UnRegisterHiChainGroupCallback_001
815 * @tc.desc: return DM_OK
816 * @tc.type: FUNC
817 * @tc.require: AR000GHSJK
818 */
819 HWTEST_F(HichainConnectorTest, UnRegisterHiChainGroupCallback_001, testing::ext::TestSize.Level1)
820 {
821 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
822 int32_t ret = hiChainConnector->UnRegisterHiChainGroupCallback();
823 EXPECT_EQ(ret, DM_OK);
824 }
825
826 /**
827 * @tc.name: getRegisterInfo_001
828 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
829 * @tc.type: FUNC
830 * @tc.require: AR000GHSJK
831 */
832 HWTEST_F(HichainConnectorTest, getRegisterInfo_001, testing::ext::TestSize.Level1)
833 {
834 std::string queryParams;
835 std::string returnJsonStr;
836 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
837 hiChainConnector->deviceGroupManager_ = nullptr;
838 int32_t ret = hiChainConnector->getRegisterInfo(queryParams, returnJsonStr);
839 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
840 }
841
842 /**
843 * @tc.name: getRegisterInfo_002
844 * @tc.desc: return ERR_DM_FAILED
845 * @tc.type: FUNC
846 * @tc.require: AR000GHSJK
847 */
848 HWTEST_F(HichainConnectorTest, getRegisterInfo_002, testing::ext::TestSize.Level1)
849 {
850 std::string queryParams;
851 std::string returnJsonStr;
852 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
853 int32_t ret = hiChainConnector->getRegisterInfo(queryParams, returnJsonStr);
854 EXPECT_EQ(ret, ERR_DM_FAILED);
855 }
856
857 /**
858 * @tc.name: ParseRemoteCredential_001
859 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
860 * @tc.type: FUNC
861 * @tc.require: AR000GHSJK
862 */
863 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_001, testing::ext::TestSize.Level1)
864 {
865 int32_t groupType = 1;
866 std::string userId;
867 JsonObject jsonDeviceList;
868 std::string params = "paramsTest";
869 int32_t osAccountUserId = 0;
870 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
871 int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
872 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
873 }
874
875 /**
876 * @tc.name: ParseRemoteCredential_002
877 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
878 * @tc.type: FUNC
879 * @tc.require: AR000GHSJK
880 */
881 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_002, testing::ext::TestSize.Level1)
882 {
883 int32_t groupType = 1;
884 std::string userId = "1321231";
885 JsonObject jsonDeviceList;
886 std::string params = "paramsTest";
887 int32_t osAccountUserId = 0;
888 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
889 int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
890 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
891 }
892
893 /**
894 * @tc.name: ParseRemoteCredential_003
895 * @tc.desc: return ERR_DM_FAILED
896 * @tc.type: FUNC
897 * @tc.require: AR000GHSJK
898 */
899 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_003, testing::ext::TestSize.Level1)
900 {
901 int32_t groupType = 1;
902 std::string userId = "1321231";
903 JsonObject jsonDeviceList;
904 jsonDeviceList[FIELD_DEVICE_LIST] = "15264646";
905 std::string params = "paramsTest";
906 int32_t osAccountUserId = 0;
907 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
908 int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
909 EXPECT_EQ(ret, ERR_DM_FAILED);
910 }
911
912 /**
913 * @tc.name: addMultiMembers_001
914 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
915 * @tc.type: FUNC
916 * @tc.require: AR000GHSJK
917 */
918 HWTEST_F(HichainConnectorTest, addMultiMembers_001, testing::ext::TestSize.Level1)
919 {
920 int32_t groupType = 1;
921 std::string userId = "";
922 JsonObject jsonDeviceList;
923 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
924 hiChainConnector->deviceGroupManager_ = nullptr;
925 int32_t ret = hiChainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
926 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
927 }
928
929 /**
930 * @tc.name: addMultiMembers_002
931 * @tc.desc: return ERR_DM_FAILED
932 * @tc.type: FUNC
933 * @tc.require: AR000GHSJK
934 */
935 HWTEST_F(HichainConnectorTest, addMultiMembers_002, testing::ext::TestSize.Level1)
936 {
937 int32_t groupType = 1;
938 std::string userId = "userIdTest";
939 JsonObject jsonDeviceList;
940 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
941 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
942 int32_t ret = hiChainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
943 EXPECT_EQ(ret, ERR_DM_FAILED);
944 }
945
946 /**
947 * @tc.name: deleteMultiMembers_001
948 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
949 * @tc.type: FUNC
950 * @tc.require: AR000GHSJK
951 */
952 HWTEST_F(HichainConnectorTest, deleteMultiMembers_001, testing::ext::TestSize.Level1)
953 {
954 int32_t groupType = 1;
955 std::string userId = "userIdTest";
956 JsonObject jsonDeviceList;
957 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
958 hiChainConnector->deviceGroupManager_ = nullptr;
959 int32_t ret = hiChainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
960 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
961 }
962
963 /**
964 * @tc.name: deleteMultiMembers_002
965 * @tc.desc: return ERR_DM_FAILED
966 * @tc.type: FUNC
967 * @tc.require: AR000GHSJK
968 */
969 HWTEST_F(HichainConnectorTest, deleteMultiMembers_002, testing::ext::TestSize.Level1)
970 {
971 int32_t groupType = 1;
972 std::string userId = "";
973 JsonObject jsonDeviceList;
974 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
975 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
976 int32_t ret = hiChainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
977 EXPECT_EQ(ret, ERR_DM_FAILED);
978 }
979
980 /**
981 * @tc.name: IsDevicesInP2PGroup_001
982 * @tc.desc: return false
983 * @tc.type: FUNC
984 * @tc.require: AR000GHSJK
985 */
986 HWTEST_F(HichainConnectorTest, IsDevicesInP2PGroup_001, testing::ext::TestSize.Level1)
987 {
988 std::string hostDevice = "hostDeviceTest";
989 std::string peerDevice = "peerDeviceTest";
990 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
991 bool ret = hiChainConnector->IsDevicesInP2PGroup(hostDevice, peerDevice);
992 EXPECT_EQ(ret, false);
993 }
994
995 /**
996 * @tc.name: UnRegisterHiChainCallback_001
997 * @tc.desc: return DM_OK
998 * @tc.type: FUNC
999 * @tc.require: AR000GHSJK
1000 */
1001 HWTEST_F(HichainConnectorTest, UnRegisterHiChainCallback_001, testing::ext::TestSize.Level1)
1002 {
1003 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1004 int32_t ret = hiChainConnector->UnRegisterHiChainCallback();
1005 EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
1006 EXPECT_EQ(ret, DM_OK);
1007 }
1008
1009 /**
1010 * @tc.name: GetGroupInfo_001
1011 * @tc.desc: return false
1012 * @tc.type: FUNC
1013 * @tc.require: AR000GHSJK
1014 */
1015 HWTEST_F(HichainConnectorTest, GetGroupInfo_001, testing::ext::TestSize.Level1)
1016 {
1017 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1018 std::string queryParams;
1019 std::vector<GroupInfo> groupList;
1020 bool ret = hiChainConnector->GetGroupInfo(queryParams, groupList);
1021 EXPECT_EQ(ret, false);
1022 }
1023
1024 /**
1025 * @tc.name: GetGroupInfo_002
1026 * @tc.desc: return DM_OK
1027 * @tc.type: FUNC
1028 * @tc.require: AR000GHSJK
1029 */
1030 HWTEST_F(HichainConnectorTest, GetGroupInfo_002, testing::ext::TestSize.Level1)
1031 {
1032 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1033 int32_t userId = 12;
1034 std::string queryParams;
1035 std::vector<GroupInfo> groupList;
1036 int32_t ret = hiChainConnector->GetGroupInfo(userId, queryParams, groupList);
1037 EXPECT_EQ(ret, DM_OK);
1038 }
1039
1040 /**
1041 * @tc.name: GetGroupType_001
1042 * @tc.desc: return DM_OK
1043 * @tc.type: FUNC
1044 * @tc.require: AR000GHSJK
1045 */
1046 HWTEST_F(HichainConnectorTest, GetGroupType_001, testing::ext::TestSize.Level1)
1047 {
1048 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1049 std::string deviceId;
1050 auto ret = hiChainConnector->GetGroupType(deviceId);
1051 EXPECT_EQ(ret, DmAuthForm::INVALID_TYPE);
1052 }
1053
1054 /**
1055 * @tc.name: DeleteGroupExt_001
1056 * @tc.desc: set groupId = "34567", and return ERR_DM_FAILED
1057 * @tc.type: FUNC
1058 * @tc.require: AR000GHSJK
1059 */
1060 HWTEST_F(HichainConnectorTest, DeleteGroupExt_001, testing::ext::TestSize.Level1)
1061 {
1062 std::string groupId = "34567";
1063 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1064 int ret = hiChainConnector->DeleteGroupExt(groupId);
1065 EXPECT_EQ(ret, ERR_DM_FAILED);
1066 }
1067
1068 /**
1069 * @tc.name: DeleteTimeOutGroup_001
1070 * @tc.desc: return DM_OK
1071 * @tc.type: FUNC
1072 * @tc.require: AR000GHSJK
1073 */
1074 HWTEST_F(HichainConnectorTest, DeleteTimeOutGroup_001, testing::ext::TestSize.Level1)
1075 {
1076 std::string deviceId = "13245631";
1077 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1078 int ret = hiChainConnector->DeleteTimeOutGroup(deviceId.c_str());
1079 EXPECT_EQ(ret, DM_OK);
1080 }
1081
1082 /**
1083 * @tc.name: DealRedundanceGroup_001
1084 * @tc.type: FUNC
1085 * @tc.require: AR000GHSJK
1086 */
1087 HWTEST_F(HichainConnectorTest, DealRedundanceGroup_001, testing::ext::TestSize.Level1)
1088 {
1089 std::string userId = "13245631";
1090 int32_t authType = 1;
1091 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1092 hiChainConnector->DealRedundanceGroup(userId, authType);
1093 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1094 }
1095
1096 /**
1097 * @tc.name: GetGroupId_001
1098 * @tc.desc: return ERR_DM_FAILED
1099 * @tc.type: FUNC
1100 * @tc.require: AR000GHSJK
1101 */
1102 HWTEST_F(HichainConnectorTest, GetGroupId_001, testing::ext::TestSize.Level1)
1103 {
1104 std::string userId = "13245631";
1105 int32_t authType = 1;
1106 std::string groupId = "232310";
1107 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1108 int32_t ret = hiChainConnector->GetGroupId(userId, authType, groupId);
1109 EXPECT_EQ(ret, ERR_DM_FAILED);
1110 }
1111
1112 /**
1113 * @tc.name: GetJsonStr_001
1114 * @tc.desc: return true
1115 * @tc.type: FUNC
1116 * @tc.require: AR000GHSJK
1117 */
1118 HWTEST_F(HichainConnectorTest, GetJsonStr_001, testing::ext::TestSize.Level1)
1119 {
1120 JsonObject jsonObj;
1121 std::string key;
1122 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1123 auto ret = hiChainConnector->GetJsonStr(jsonObj, key);
1124 EXPECT_EQ(ret.empty(), true);
1125 }
1126
1127 /**
1128 * @tc.name: GetJsonStr_002
1129 * @tc.desc: return false
1130 * @tc.type: FUNC
1131 * @tc.require: AR000GHSJK
1132 */
1133 HWTEST_F(HichainConnectorTest, GetJsonStr_002, testing::ext::TestSize.Level1)
1134 {
1135 std::string key = "key";
1136 JsonObject jsonObj;
1137 jsonObj[key] = "232513";
1138 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1139 auto ret = hiChainConnector->GetJsonStr(jsonObj, key);
1140 EXPECT_EQ(ret.empty(), false);
1141 }
1142
1143 /**
1144 * @tc.name: GetJsonInt_001
1145 * @tc.desc: return ERR_DM_FAILED
1146 * @tc.type: FUNC
1147 * @tc.require: AR000GHSJK
1148 */
1149 HWTEST_F(HichainConnectorTest, GetJsonInt_001, testing::ext::TestSize.Level1)
1150 {
1151 JsonObject jsonObj;
1152 std::string key;
1153 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1154 int32_t ret = hiChainConnector->GetJsonInt(jsonObj, key);
1155 EXPECT_EQ(ret, ERR_DM_FAILED);
1156 }
1157
1158 /**
1159 * @tc.name: GetJsonInt_002
1160 * @tc.desc: return 232513
1161 * @tc.type: FUNC
1162 * @tc.require: AR000GHSJK
1163 */
1164 HWTEST_F(HichainConnectorTest, GetJsonInt_002, testing::ext::TestSize.Level1)
1165 {
1166 std::string key = "12";
1167 JsonObject jsonObj;
1168 jsonObj[key] = 232513;
1169 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1170 int32_t ret = hiChainConnector->GetJsonInt(jsonObj, key);
1171 EXPECT_EQ(ret, 232513);
1172 }
1173
1174 /**
1175 * @tc.name: GetGroupIdExt_001
1176 * @tc.desc: return ERR_DM_FAILED
1177 * @tc.type: FUNC
1178 * @tc.require: AR000GHSJK
1179 */
1180 HWTEST_F(HichainConnectorTest, GetGroupIdExt_001, testing::ext::TestSize.Level1)
1181 {
1182 std::string userId = "12";
1183 int32_t groupType = 1;
1184 std::string groupId;
1185 std::string groupOwner;
1186 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1187 int32_t ret = hiChainConnector->GetGroupIdExt(userId, groupType, groupId, groupOwner);
1188 EXPECT_EQ(ret, ERR_DM_FAILED);
1189 }
1190
1191 /**
1192 * @tc.name: ParseRemoteCredentialExt_001
1193 * @tc.desc: return ERR_DM_FAILED
1194 * @tc.type: FUNC
1195 * @tc.require: AR000GHSJK
1196 */
1197 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_001, testing::ext::TestSize.Level1)
1198 {
1199 std::string credentialInfo;
1200 std::string params;
1201 std::string groupOwner;
1202 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1203 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1204 EXPECT_EQ(ret, ERR_DM_FAILED);
1205 }
1206
1207 /**
1208 * @tc.name: ParseRemoteCredentialExt_002
1209 * @tc.desc: return ERR_DM_FAILED
1210 * @tc.type: FUNC
1211 * @tc.require: AR000GHSJK
1212 */
1213 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_002, testing::ext::TestSize.Level1)
1214 {
1215 JsonObject jsonObj;
1216 std::string credentialInfo = jsonObj.Dump();
1217 std::string params;
1218 std::string groupOwner;
1219 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1220 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1221 EXPECT_EQ(ret, ERR_DM_FAILED);
1222 }
1223
1224 /**
1225 * @tc.name: ParseRemoteCredentialExt_003
1226 * @tc.desc: return ERR_DM_FAILED
1227 * @tc.type: FUNC
1228 * @tc.require: AR000GHSJK
1229 */
1230 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_003, testing::ext::TestSize.Level1)
1231 {
1232 JsonObject jsonObj;
1233 jsonObj["authType"] = 1;
1234 jsonObj[FIELD_USER_ID] = "156103";
1235 std::string credentialInfo = jsonObj.Dump();
1236 std::string params;
1237 std::string groupOwner;
1238 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1239 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1240 EXPECT_EQ(ret, ERR_DM_FAILED);
1241 }
1242
1243 /**
1244 * @tc.name: ParseRemoteCredentialExt_004
1245 * @tc.desc: return ERR_DM_FAILED
1246 * @tc.type: FUNC
1247 * @tc.require: AR000GHSJK
1248 */
1249 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_004, testing::ext::TestSize.Level1)
1250 {
1251 JsonObject jsonObj;
1252 jsonObj["authType"] = 4;
1253 jsonObj[FIELD_USER_ID] = "156103";
1254 std::string credentialInfo = jsonObj.Dump();
1255 std::string params;
1256 std::string groupOwner;
1257 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1258 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1259 EXPECT_EQ(ret, ERR_DM_FAILED);
1260 }
1261
1262 /**
1263 * @tc.name: addMultiMembersExt_001
1264 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1265 * @tc.type: FUNC
1266 * @tc.require: AR000GHSJK
1267 */
1268 HWTEST_F(HichainConnectorTest, addMultiMembersExt_001, testing::ext::TestSize.Level1)
1269 {
1270 std::string credentialInfo;
1271 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1272 hiChainConnector->deviceGroupManager_ = nullptr;
1273 int32_t ret = hiChainConnector->addMultiMembersExt(credentialInfo);
1274 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1275 }
1276
1277 /**
1278 * @tc.name: addMultiMembersExt_002
1279 * @tc.desc: return ERR_DM_FAILED
1280 * @tc.type: FUNC
1281 * @tc.require: AR000GHSJK
1282 */
1283 HWTEST_F(HichainConnectorTest, addMultiMembersExt_002, testing::ext::TestSize.Level1)
1284 {
1285 JsonObject jsonObj;
1286 std::string credentialInfo = jsonObj.Dump();
1287 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1288 int32_t ret = hiChainConnector->addMultiMembersExt(credentialInfo);
1289 EXPECT_EQ(ret, ERR_DM_FAILED);
1290 }
1291
1292 /**
1293 * @tc.name: GetTrustedDevices_001
1294 * @tc.desc: return true
1295 * @tc.type: FUNC
1296 * @tc.require: AR000GHSJK
1297 */
1298 HWTEST_F(HichainConnectorTest, GetTrustedDevices_001, testing::ext::TestSize.Level1)
1299 {
1300 std::string localDeviceUdid;
1301 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1302 auto ret = hiChainConnector->GetTrustedDevices(localDeviceUdid);
1303 EXPECT_EQ(ret.empty(), true);
1304 }
1305
1306 /**
1307 * @tc.name: GetTrustedDevicesUdid_001
1308 * @tc.desc: return ERR_DM_FAILED
1309 * @tc.type: FUNC
1310 * @tc.require: AR000GHSJK
1311 */
1312 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_001, testing::ext::TestSize.Level1)
1313 {
1314 std::string jsonStr;
1315 std::vector<std::string> udidList;
1316 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1317 int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr.c_str(), udidList);
1318 EXPECT_EQ(ret, ERR_DM_FAILED);
1319 }
1320
1321 /**
1322 * @tc.name: GetTrustedDevicesUdid_002
1323 * @tc.desc: return DM_OK
1324 * @tc.type: FUNC
1325 * @tc.require: AR000GHSJK
1326 */
1327 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_002, testing::ext::TestSize.Level1)
1328 {
1329 JsonObject jsonObj;
1330 std::string jsonStr = jsonObj.Dump();
1331 std::vector<std::string> udidList;
1332 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1333 int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr.c_str(), udidList);
1334 EXPECT_EQ(ret, DM_OK);
1335 }
1336
1337 /**
1338 * @tc.name: GetTrustedDevicesUdid_003
1339 * @tc.desc: Verify that the function returns DM_OK and correctly populates the udidList.
1340 * @tc.type: FUNC
1341 * @tc.require: AR000GHSJK
1342 */
1343 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_003, testing::ext::TestSize.Level1)
1344 {
1345 const char* jsonStr = R"({
1346 "device1": {
1347 "authId": "valid_udid_1"
1348 },
1349 "device2": {
1350 "authId": 12345
1351 },
1352 "device3": {
1353 "authId": "valid_udid_2"
1354 }
1355 })";
1356
1357 std::vector<std::string> udidList;
1358 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1359 int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr, udidList);
1360 EXPECT_EQ(ret, DM_OK);
1361
1362 std::vector<std::string> expectedUdidList = {"valid_udid_1", "valid_udid_2"};
1363 EXPECT_EQ(udidList, expectedUdidList);
1364 }
1365
1366 /**
1367 * @tc.name: DeleteAllGroup_001
1368 * @tc.type: FUNC
1369 * @tc.require: AR000GHSJK
1370 */
1371 HWTEST_F(HichainConnectorTest, DeleteAllGroup_001, testing::ext::TestSize.Level1)
1372 {
1373 int32_t userId = 1;
1374 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1375 hiChainConnector->DeleteAllGroup(userId);
1376 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1377 }
1378
1379 /**
1380 * @tc.name: GetRelatedGroupsCommon_001
1381 * @tc.desc: return ERR_DM_FAILED
1382 * @tc.type: FUNC
1383 * @tc.require: AR000GHSJK
1384 */
1385 HWTEST_F(HichainConnectorTest, GetRelatedGroupsCommon_001, testing::ext::TestSize.Level1)
1386 {
1387 std::string deviceId;
1388 std::string pkgName;
1389 std::vector<GroupInfo> groupList;
1390 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1391 int32_t ret = hiChainConnector->GetRelatedGroupsCommon(deviceId, pkgName.c_str(), groupList);
1392 EXPECT_EQ(ret, ERR_DM_FAILED);
1393 }
1394 } // namespace
1395 } // namespace DistributedHardware
1396 } // namespace OHOS
1397