1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "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)55 void OnMemberJoin(int64_t requestId, int32_t status) override
56 {
57 (void)requestId;
58 (void)status;
59 }
GetConnectAddr(std::string deviceId)60 std::string GetConnectAddr(std::string deviceId)
61 {
62 return "";
63 }
GetPinCode(int32_t & code)64 int32_t GetPinCode(int32_t &code)
65 {
66 int32_t pinCode = 123456;
67 code = pinCode;
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.Level0)
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.Level0)
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.Level0)
111 {
112 int64_t requestId = 159357;
113 int32_t authType = 1;
114 std::string userId = "userIdTest";
115 nlohmann::json 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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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 nlohmann::json 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 from_json(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.Level0)
242 {
243 GroupInfo groupInfo;
244 groupInfo.userId = "test";
245 groupInfo.groupName = "test";
246 nlohmann::json 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 from_json(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.groupName = "";
263 jsonObject[FIELD_GROUP_NAME] = "groupNameInfo";
264 from_json(jsonObject, groupInfo);
265 EXPECT_EQ(groupInfo.groupName, "groupNameInfo");
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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 EXPECT_NE(hiChainConnector->onRequest(requestId, operationCode, reqParams), nullptr);
424
425 EXPECT_CALL(*mockCallback, GetPinCode(testing::_))
426 .Times(1)
427 .WillOnce(testing::Return(DM_OK));
428 EXPECT_NE(hiChainConnector->onRequest(requestId, operationCode, reqParams), nullptr);
429 }
430
431 /**
432 * @tc.name: GetConnectPara_001
433 * @tc.desc: Test GetConnectPara method when hiChainConnectorCallback_ is set to nullptr,
434 * ensuring it returns an empty string.
435 * @tc.type: FUNC
436 * @tc.require: AR000GHSJK
437 */
438 HWTEST_F(HichainConnectorTest, GetConnectPara_001, testing::ext::TestSize.Level0)
439 {
440 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
441 hiChainConnector->hiChainConnectorCallback_ = nullptr;
442 std::string deviceId = "12345";
443 std::string reqDeviceId = "12345";
444 std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
445 EXPECT_EQ(ret, "");
446 }
447
448 /**
449 * @tc.name: GetConnectPara_002
450 * @tc.desc: Test GetConnectPara method with an empty deviceId to ensure JSON parsing fails
451 * and returns an empty string.
452 * @tc.type: FUNC
453 * @tc.require: AR000GHSJK
454 */
455 HWTEST_F(HichainConnectorTest, GetConnectPara_002, testing::ext::TestSize.Level0)
456 {
457 std::string deviceId;
458 std::string reqDeviceId = "12345";
459 std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
460 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
461 hiChainConnector->hiChainConnectorCallback_ = mockCallback;
462 EXPECT_CALL(*mockCallback, GetConnectAddr(testing::_))
463 .Times(1)
464 .WillOnce(testing::Return(R"({"key": "value"})"));
465 std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
466 EXPECT_NE(ret, "");
467 }
468
469 /**
470 * @tc.name: GetConnectPara_003
471 * @tc.desc: Test GetConnectPara method with invalid JSON returned by hiChainConnectorCallback_
472 * to ensure it returns an empty string.
473 * @tc.type: FUNC
474 * @tc.require: AR000GHSJK
475 */
476 HWTEST_F(HichainConnectorTest, GetConnectPara_003, testing::ext::TestSize.Level0)
477 {
478 std::string deviceId;
479 std::string reqDeviceId = "12345";
480 std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
481 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
482 hiChainConnector->hiChainConnectorCallback_ = mockCallback;
483 EXPECT_CALL(*mockCallback, GetConnectAddr(testing::_))
484 .Times(1)
485 .WillOnce(testing::Return("invalid json"));
486 std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
487 EXPECT_EQ(ret, "invalid json");
488 }
489
490 /**
491 * @tc.name: DeleteGroup_001
492 * @tc.desc: set groupId = "34567", and return ERR_DM_FAILED
493 * @tc.type: FUNC
494 * @tc.require: AR000GHSJK
495 */
496 HWTEST_F(HichainConnectorTest, DeleteGroup_001, testing::ext::TestSize.Level0)
497 {
498 std::string groupId = "34567";
499 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
500 int ret = hiChainConnector->DeleteGroup(groupId);
501 EXPECT_EQ(ret, ERR_DM_FAILED);
502 }
503
504 /**
505 * @tc.name: GetRelatedGroups_001
506 * @tc.desc: set DeviceId 123 groupList null and return ERR_DM_FAILED
507 * @tc.type: FUNC
508 * @tc.require: AR000GHSJK
509 */
510 HWTEST_F(HichainConnectorTest, GetRelatedGroups_001, testing::ext::TestSize.Level0)
511 {
512 std::string deviceId = "123";
513 std::vector<GroupInfo> groupList;
514 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
515 int ret = hiChainConnector->GetRelatedGroups(deviceId, groupList);
516 EXPECT_EQ(ret, ERR_DM_FAILED);
517 }
518
519 /**
520 * @tc.name: GetRelatedGroupsExt_001
521 * @tc.desc: set DeviceId = 12345,groupList null and return ERR_DM_FAILED
522 * @tc.type: FUNC
523 * @tc.require: AR000GHSJK
524 */
525 HWTEST_F(HichainConnectorTest, GetRelatedGroupsExt_001, testing::ext::TestSize.Level0)
526 {
527 std::string deviceId = "12345";
528 std::vector<GroupInfo> groupList;
529 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
530 int ret = hiChainConnector->GetRelatedGroupsExt(deviceId, groupList);
531 EXPECT_EQ(ret, ERR_DM_FAILED);
532 }
533
534 /**
535 * @tc.name: SyncGroups_001
536 * @tc.desc: set deviceId = "34567", and return DM_OK
537 * @tc.type: FUNC
538 * @tc.require: AR000GHSJK
539 */
540 HWTEST_F(HichainConnectorTest, SyncGroups_001, testing::ext::TestSize.Level0)
541 {
542 std::string deviceId = "34567";
543 std::vector<std::string> remoteGroupIdList;
544 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
545 int ret = hiChainConnector->SyncGroups(deviceId, remoteGroupIdList);
546 EXPECT_EQ(ret, DM_OK);
547 }
548
549 /**
550 * @tc.name: GetSyncGroupList_001
551 * @tc.desc: set groupList null, and return ERR_DM_FAILED
552 * @tc.type: FUNC
553 * @tc.require: AR000GHSJK
554 */
555 HWTEST_F(HichainConnectorTest, GetSyncGroupList_001, testing::ext::TestSize.Level0)
556 {
557 std::vector<GroupInfo> groupList;
558 std::vector<std::string> syncGroupList;
559 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
560 int ret = hiChainConnector->GetSyncGroupList(groupList, syncGroupList);
561 EXPECT_EQ(ret, ERR_DM_FAILED);
562 }
563
564 /**
565 * @tc.name: GetSyncGroupList_002
566 * @tc.desc: set groupList not null, and return DM_OK
567 * @tc.type: FUNC
568 * @tc.require: AR000GHSJK
569 */
570 HWTEST_F(HichainConnectorTest, GetSyncGroupList_002, testing::ext::TestSize.Level0)
571 {
572 std::vector<GroupInfo> groupList;
573 GroupInfo groupList1;
574 groupList1.groupName = "groupName";
575 groupList1.groupId = 1;
576 groupList1.groupOwner = "ohos.distributedhardware.devicemanager";
577 groupList1.groupType = 7;
578 groupList1.groupVisibility = 1;
579 groupList.push_back(groupList1);
580 GroupInfo groupList2;
581 groupList2.groupName = "hichainconnector";
582 groupList2.groupId = "123456";
583 groupList2.groupOwner = "doftbus";
584 groupList2.groupType = 1;
585 groupList2.groupVisibility = 2;
586 groupList.push_back(groupList2);
587 std::vector<std::string> syncGroupList;
588 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
589 int ret = hiChainConnector->GetSyncGroupList(groupList, syncGroupList);
590 EXPECT_EQ(ret, DM_OK);
591 }
592
593 /**
594 * @tc.name: IsGroupCreated_001
595 * @tc.desc: return false
596 * @tc.type: FUNC
597 * @tc.require: AR000GHSJK
598 */
599 HWTEST_F(HichainConnectorTest, IsGroupCreated_001, testing::ext::TestSize.Level0)
600 {
601 std::string groupName = "groupNameTest";
602 GroupInfo groupInfo;
603 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
604 bool ret = hiChainConnector->IsGroupCreated(groupName, groupInfo);
605 EXPECT_EQ(ret, false);
606 }
607
608 /**
609 * @tc.name: IsRedundanceGroup_001
610 * @tc.desc: return false
611 * @tc.type: FUNC
612 * @tc.require: AR000GHSJK
613 */
614 HWTEST_F(HichainConnectorTest, IsRedundanceGroup_001, testing::ext::TestSize.Level0)
615 {
616 const std::string userId = "userIdTest";
617 int32_t authType = 1;
618 std::vector<GroupInfo> groupList;
619 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
620 bool ret = hiChainConnector->IsRedundanceGroup(userId, authType, groupList);
621 EXPECT_EQ(ret, false);
622 }
623
624 /**
625 * @tc.name: onFinish_001
626 * @tc.desc: return DM_OK
627 * @tc.type: FUNC
628 * @tc.require: AR000GHSJK
629 */
630 HWTEST_F(HichainConnectorTest, onFinish_001, testing::ext::TestSize.Level0)
631 {
632 int64_t requestId = 1;
633 int operationCode = GroupOperationCode::MEMBER_JOIN;
634 const char *returnData = "returnDataTest";
635 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
636 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
637
638 hiChainConnector->onFinish(requestId, operationCode, returnData);
639
640 operationCode = GroupOperationCode::GROUP_CREATE;
641 hiChainConnector->onFinish(requestId, operationCode, returnData);
642
643 operationCode = GroupOperationCode::MEMBER_DELETE;
644 hiChainConnector->onFinish(requestId, operationCode, returnData);
645
646 operationCode = GroupOperationCode::GROUP_DISBAND;
647 hiChainConnector->onFinish(requestId, operationCode, returnData);
648 EXPECT_EQ(ret, DM_OK);
649 }
650
651 /**
652 * @tc.name: onFinish_002
653 * @tc.desc: return DM_OK
654 * @tc.type: FUNC
655 * @tc.require: AR000GHSJK
656 */
657 HWTEST_F(HichainConnectorTest, onFinish_002, testing::ext::TestSize.Level0)
658 {
659 int64_t requestId = 1;
660 int operationCode = GroupOperationCode::MEMBER_JOIN;
661 const char *returnData = "returnDataTest";
662 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
663 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
664 EXPECT_EQ(ret, DM_OK);
665 ret = hiChainConnector->UnRegisterHiChainCallback();
666 EXPECT_EQ(ret, DM_OK);
667
668 hiChainConnector->onFinish(requestId, operationCode, returnData);
669
670 operationCode = GroupOperationCode::GROUP_CREATE;
671 hiChainConnector->onFinish(requestId, operationCode, returnData);
672
673 hiChainConnector->networkStyle_ = 1;
674 hiChainConnector->hiChainResCallback_ = nullptr;
675 hiChainConnector->onFinish(requestId, operationCode, returnData);
676
677 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
678 std::shared_ptr<HiChainConnector> hiChainConn = std::make_shared<HiChainConnector>();
679 hiChainConnector->hiChainResCallback_ = std::make_shared<DmCredentialManager>(hiChainConn, listener);
680 hiChainConnector->onFinish(requestId, operationCode, returnData);
681
682 operationCode = GroupOperationCode::GROUP_DISBAND;
683 hiChainConnector->onFinish(requestId, operationCode, returnData);
684
685 hiChainConnector->hiChainResCallback_ = nullptr;
686 hiChainConnector->onFinish(requestId, operationCode, returnData);
687
688 EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
689 }
690
691 /**
692 * @tc.name: onError_001
693 * @tc.desc: return DM_OK
694 * @tc.type: FUNC
695 * @tc.require: AR000GHSJK
696 */
697 HWTEST_F(HichainConnectorTest, onError_001, testing::ext::TestSize.Level0)
698 {
699 int64_t requestId = 1;
700 int operationCode = GroupOperationCode::MEMBER_JOIN;
701 int errorCode = 1;
702 const char *errorReturn = "errorReturnTest";
703 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
704 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
705 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
706
707 operationCode = GroupOperationCode::GROUP_CREATE;
708 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
709
710 operationCode = GroupOperationCode::MEMBER_DELETE;
711 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
712
713 operationCode = GroupOperationCode::GROUP_DISBAND;
714 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
715 EXPECT_EQ(ret, DM_OK);
716 }
717
718 /**
719 * @tc.name: onError_002
720 * @tc.desc: return DM_OK
721 * @tc.type: FUNC
722 * @tc.require: AR000GHSJK
723 */
724 HWTEST_F(HichainConnectorTest, onError_002, testing::ext::TestSize.Level0)
725 {
726 int64_t requestId = 1;
727 int operationCode = GroupOperationCode::MEMBER_JOIN;
728 int errorCode = 1;
729 const char *errorReturn = "errorReturnTest";
730 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
731 int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
732 EXPECT_EQ(ret, DM_OK);
733 ret = hiChainConnector->UnRegisterHiChainCallback();
734 EXPECT_EQ(ret, DM_OK);
735 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
736
737 operationCode = GroupOperationCode::GROUP_CREATE;
738 hiChainConnector->networkStyle_ = 0;
739 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
740
741 hiChainConnector->networkStyle_ = 1;
742 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
743
744 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
745 std::shared_ptr<HiChainConnector> hiChainConn = std::make_shared<HiChainConnector>();
746 hiChainConnector->hiChainResCallback_ = std::make_shared<DmCredentialManager>(hiChainConn, listener);
747 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
748
749 operationCode = GroupOperationCode::GROUP_DISBAND;
750 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
751
752 hiChainConnector->hiChainResCallback_ = nullptr;
753 hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
754 EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
755 }
756
757 /**
758 * @tc.name: DeleteGroup_002
759 * @tc.desc: return ERR_DM_FAILED
760 * @tc.type: FUNC
761 * @tc.require: AR000GHSJK
762 */
763 HWTEST_F(HichainConnectorTest, DeleteGroup_002, testing::ext::TestSize.Level0)
764 {
765 const int32_t userId = 1;
766 std::string groupId = "groupIdTest";
767 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
768 int32_t ret = hiChainConnector->DeleteGroup(userId, groupId);
769 EXPECT_EQ(ret, ERR_DM_FAILED);
770 }
771
772 /**
773 * @tc.name: DeleteGroup_003
774 * @tc.desc: return ERR_DM_FAILED
775 * @tc.type: FUNC
776 * @tc.require: AR000GHSJK
777 */
778 HWTEST_F(HichainConnectorTest, DeleteGroup_003, testing::ext::TestSize.Level0)
779 {
780 int64_t requestId = 1;
781 std::string userId = "userIdTest";
782 const int32_t authType = 1;
783 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
784 hiChainConnector->DeleteRedundanceGroup(userId);
785 int32_t ret = hiChainConnector->DeleteGroup(requestId, userId, authType);
786 EXPECT_EQ(ret, ERR_DM_FAILED);
787 }
788
789 /**
790 * @tc.name: RegisterHiChainGroupCallback_001
791 * @tc.desc: return DM_OK
792 * @tc.type: FUNC
793 * @tc.require: AR000GHSJK
794 */
795 HWTEST_F(HichainConnectorTest, RegisterHiChainGroupCallback_001, testing::ext::TestSize.Level0)
796 {
797 std::shared_ptr<IDmGroupResCallback> callback = nullptr;
798 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
799 int32_t ret = hiChainConnector->RegisterHiChainGroupCallback(callback);
800 EXPECT_EQ(ret, DM_OK);
801 }
802
803 /**
804 * @tc.name: UnRegisterHiChainGroupCallback_001
805 * @tc.desc: return DM_OK
806 * @tc.type: FUNC
807 * @tc.require: AR000GHSJK
808 */
809 HWTEST_F(HichainConnectorTest, UnRegisterHiChainGroupCallback_001, testing::ext::TestSize.Level0)
810 {
811 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
812 int32_t ret = hiChainConnector->UnRegisterHiChainGroupCallback();
813 EXPECT_EQ(ret, DM_OK);
814 }
815
816 /**
817 * @tc.name: getRegisterInfo_001
818 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
819 * @tc.type: FUNC
820 * @tc.require: AR000GHSJK
821 */
822 HWTEST_F(HichainConnectorTest, getRegisterInfo_001, testing::ext::TestSize.Level0)
823 {
824 std::string queryParams;
825 std::string returnJsonStr;
826 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
827 hiChainConnector->deviceGroupManager_ = nullptr;
828 int32_t ret = hiChainConnector->getRegisterInfo(queryParams, returnJsonStr);
829 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
830 }
831
832 /**
833 * @tc.name: getRegisterInfo_002
834 * @tc.desc: return ERR_DM_FAILED
835 * @tc.type: FUNC
836 * @tc.require: AR000GHSJK
837 */
838 HWTEST_F(HichainConnectorTest, getRegisterInfo_002, testing::ext::TestSize.Level0)
839 {
840 std::string queryParams;
841 std::string returnJsonStr;
842 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
843 int32_t ret = hiChainConnector->getRegisterInfo(queryParams, returnJsonStr);
844 EXPECT_EQ(ret, ERR_DM_FAILED);
845 }
846
847 /**
848 * @tc.name: ParseRemoteCredential_001
849 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
850 * @tc.type: FUNC
851 * @tc.require: AR000GHSJK
852 */
853 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_001, testing::ext::TestSize.Level0)
854 {
855 int32_t groupType = 1;
856 std::string userId;
857 nlohmann::json jsonDeviceList;
858 std::string params = "paramsTest";
859 int32_t osAccountUserId = 0;
860 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
861 int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
862 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
863 }
864
865 /**
866 * @tc.name: ParseRemoteCredential_002
867 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
868 * @tc.type: FUNC
869 * @tc.require: AR000GHSJK
870 */
871 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_002, testing::ext::TestSize.Level0)
872 {
873 int32_t groupType = 1;
874 std::string userId = "1321231";
875 nlohmann::json jsonDeviceList;
876 std::string params = "paramsTest";
877 int32_t osAccountUserId = 0;
878 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
879 int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
880 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
881 }
882
883 /**
884 * @tc.name: ParseRemoteCredential_003
885 * @tc.desc: return ERR_DM_FAILED
886 * @tc.type: FUNC
887 * @tc.require: AR000GHSJK
888 */
889 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_003, testing::ext::TestSize.Level0)
890 {
891 int32_t groupType = 1;
892 std::string userId = "1321231";
893 nlohmann::json jsonDeviceList;
894 jsonDeviceList[FIELD_DEVICE_LIST] = "15264646";
895 std::string params = "paramsTest";
896 int32_t osAccountUserId = 0;
897 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
898 int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
899 EXPECT_EQ(ret, ERR_DM_FAILED);
900 }
901
902 /**
903 * @tc.name: addMultiMembers_001
904 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
905 * @tc.type: FUNC
906 * @tc.require: AR000GHSJK
907 */
908 HWTEST_F(HichainConnectorTest, addMultiMembers_001, testing::ext::TestSize.Level0)
909 {
910 int32_t groupType = 1;
911 std::string userId = "";
912 nlohmann::json jsonDeviceList;
913 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
914 hiChainConnector->deviceGroupManager_ = nullptr;
915 int32_t ret = hiChainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
916 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
917 }
918
919 /**
920 * @tc.name: addMultiMembers_002
921 * @tc.desc: return ERR_DM_FAILED
922 * @tc.type: FUNC
923 * @tc.require: AR000GHSJK
924 */
925 HWTEST_F(HichainConnectorTest, addMultiMembers_002, testing::ext::TestSize.Level0)
926 {
927 int32_t groupType = 1;
928 std::string userId = "userIdTest";
929 nlohmann::json jsonDeviceList;
930 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
931 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
932 int32_t ret = hiChainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
933 EXPECT_EQ(ret, ERR_DM_FAILED);
934 }
935
936 /**
937 * @tc.name: deleteMultiMembers_001
938 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
939 * @tc.type: FUNC
940 * @tc.require: AR000GHSJK
941 */
942 HWTEST_F(HichainConnectorTest, deleteMultiMembers_001, testing::ext::TestSize.Level0)
943 {
944 int32_t groupType = 1;
945 std::string userId = "userIdTest";
946 nlohmann::json jsonDeviceList;
947 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
948 hiChainConnector->deviceGroupManager_ = nullptr;
949 int32_t ret = hiChainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
950 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
951 }
952
953 /**
954 * @tc.name: deleteMultiMembers_002
955 * @tc.desc: return ERR_DM_FAILED
956 * @tc.type: FUNC
957 * @tc.require: AR000GHSJK
958 */
959 HWTEST_F(HichainConnectorTest, deleteMultiMembers_002, testing::ext::TestSize.Level0)
960 {
961 int32_t groupType = 1;
962 std::string userId = "";
963 nlohmann::json jsonDeviceList;
964 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
965 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
966 int32_t ret = hiChainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
967 EXPECT_EQ(ret, ERR_DM_FAILED);
968 }
969
970 /**
971 * @tc.name: IsDevicesInP2PGroup_001
972 * @tc.desc: return false
973 * @tc.type: FUNC
974 * @tc.require: AR000GHSJK
975 */
976 HWTEST_F(HichainConnectorTest, IsDevicesInP2PGroup_001, testing::ext::TestSize.Level0)
977 {
978 std::string hostDevice = "hostDeviceTest";
979 std::string peerDevice = "peerDeviceTest";
980 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
981 bool ret = hiChainConnector->IsDevicesInP2PGroup(hostDevice, peerDevice);
982 EXPECT_EQ(ret, false);
983 }
984
985 /**
986 * @tc.name: UnRegisterHiChainCallback_001
987 * @tc.desc: return DM_OK
988 * @tc.type: FUNC
989 * @tc.require: AR000GHSJK
990 */
991 HWTEST_F(HichainConnectorTest, UnRegisterHiChainCallback_001, testing::ext::TestSize.Level0)
992 {
993 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
994 int32_t ret = hiChainConnector->UnRegisterHiChainCallback();
995 EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
996 EXPECT_EQ(ret, DM_OK);
997 }
998
999 /**
1000 * @tc.name: GetGroupInfo_001
1001 * @tc.desc: return false
1002 * @tc.type: FUNC
1003 * @tc.require: AR000GHSJK
1004 */
1005 HWTEST_F(HichainConnectorTest, GetGroupInfo_001, testing::ext::TestSize.Level0)
1006 {
1007 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1008 std::string queryParams;
1009 std::vector<GroupInfo> groupList;
1010 bool ret = hiChainConnector->GetGroupInfo(queryParams, groupList);
1011 EXPECT_EQ(ret, false);
1012 }
1013
1014 /**
1015 * @tc.name: GetGroupInfo_002
1016 * @tc.desc: return DM_OK
1017 * @tc.type: FUNC
1018 * @tc.require: AR000GHSJK
1019 */
1020 HWTEST_F(HichainConnectorTest, GetGroupInfo_002, testing::ext::TestSize.Level0)
1021 {
1022 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1023 int32_t userId = 12;
1024 std::string queryParams;
1025 std::vector<GroupInfo> groupList;
1026 int32_t ret = hiChainConnector->GetGroupInfo(userId, queryParams, groupList);
1027 EXPECT_EQ(ret, DM_OK);
1028 }
1029
1030 /**
1031 * @tc.name: GetGroupType_001
1032 * @tc.desc: return DM_OK
1033 * @tc.type: FUNC
1034 * @tc.require: AR000GHSJK
1035 */
1036 HWTEST_F(HichainConnectorTest, GetGroupType_001, testing::ext::TestSize.Level0)
1037 {
1038 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1039 std::string deviceId;
1040 auto ret = hiChainConnector->GetGroupType(deviceId);
1041 EXPECT_EQ(ret, DmAuthForm::INVALID_TYPE);
1042 }
1043
1044 /**
1045 * @tc.name: DeleteGroupExt_001
1046 * @tc.desc: set groupId = "34567", and return ERR_DM_FAILED
1047 * @tc.type: FUNC
1048 * @tc.require: AR000GHSJK
1049 */
1050 HWTEST_F(HichainConnectorTest, DeleteGroupExt_001, testing::ext::TestSize.Level0)
1051 {
1052 std::string groupId = "34567";
1053 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1054 int ret = hiChainConnector->DeleteGroupExt(groupId);
1055 EXPECT_EQ(ret, ERR_DM_FAILED);
1056 }
1057
1058 /**
1059 * @tc.name: DeleteTimeOutGroup_001
1060 * @tc.desc: return DM_OK
1061 * @tc.type: FUNC
1062 * @tc.require: AR000GHSJK
1063 */
1064 HWTEST_F(HichainConnectorTest, DeleteTimeOutGroup_001, testing::ext::TestSize.Level0)
1065 {
1066 std::string deviceId = "13245631";
1067 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1068 int ret = hiChainConnector->DeleteTimeOutGroup(deviceId.c_str());
1069 EXPECT_EQ(ret, DM_OK);
1070 }
1071
1072 /**
1073 * @tc.name: DealRedundanceGroup_001
1074 * @tc.type: FUNC
1075 * @tc.require: AR000GHSJK
1076 */
1077 HWTEST_F(HichainConnectorTest, DealRedundanceGroup_001, testing::ext::TestSize.Level0)
1078 {
1079 std::string userId = "13245631";
1080 int32_t authType = 1;
1081 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1082 hiChainConnector->DealRedundanceGroup(userId, authType);
1083 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1084 }
1085
1086 /**
1087 * @tc.name: GetGroupId_001
1088 * @tc.desc: return ERR_DM_FAILED
1089 * @tc.type: FUNC
1090 * @tc.require: AR000GHSJK
1091 */
1092 HWTEST_F(HichainConnectorTest, GetGroupId_001, testing::ext::TestSize.Level0)
1093 {
1094 std::string userId = "13245631";
1095 int32_t authType = 1;
1096 std::string groupId = "232310";
1097 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1098 int32_t ret = hiChainConnector->GetGroupId(userId, authType, groupId);
1099 EXPECT_EQ(ret, ERR_DM_FAILED);
1100 }
1101
1102 /**
1103 * @tc.name: GetJsonStr_001
1104 * @tc.desc: return true
1105 * @tc.type: FUNC
1106 * @tc.require: AR000GHSJK
1107 */
1108 HWTEST_F(HichainConnectorTest, GetJsonStr_001, testing::ext::TestSize.Level0)
1109 {
1110 nlohmann::json jsonObj;
1111 std::string key;
1112 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1113 auto ret = hiChainConnector->GetJsonStr(jsonObj, key);
1114 EXPECT_EQ(ret.empty(), true);
1115 }
1116
1117 /**
1118 * @tc.name: GetJsonStr_002
1119 * @tc.desc: return false
1120 * @tc.type: FUNC
1121 * @tc.require: AR000GHSJK
1122 */
1123 HWTEST_F(HichainConnectorTest, GetJsonStr_002, testing::ext::TestSize.Level0)
1124 {
1125 std::string key = "key";
1126 nlohmann::json jsonObj;
1127 jsonObj[key] = "232513";
1128 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1129 auto ret = hiChainConnector->GetJsonStr(jsonObj, key);
1130 EXPECT_EQ(ret.empty(), false);
1131 }
1132
1133 /**
1134 * @tc.name: GetJsonInt_001
1135 * @tc.desc: return ERR_DM_FAILED
1136 * @tc.type: FUNC
1137 * @tc.require: AR000GHSJK
1138 */
1139 HWTEST_F(HichainConnectorTest, GetJsonInt_001, testing::ext::TestSize.Level0)
1140 {
1141 nlohmann::json jsonObj;
1142 std::string key;
1143 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1144 int32_t ret = hiChainConnector->GetJsonInt(jsonObj, key);
1145 EXPECT_EQ(ret, ERR_DM_FAILED);
1146 }
1147
1148 /**
1149 * @tc.name: GetJsonInt_002
1150 * @tc.desc: return 232513
1151 * @tc.type: FUNC
1152 * @tc.require: AR000GHSJK
1153 */
1154 HWTEST_F(HichainConnectorTest, GetJsonInt_002, testing::ext::TestSize.Level0)
1155 {
1156 std::string key = "12";
1157 nlohmann::json jsonObj;
1158 jsonObj[key] = 232513;
1159 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1160 int32_t ret = hiChainConnector->GetJsonInt(jsonObj, key);
1161 EXPECT_EQ(ret, 232513);
1162 }
1163
1164 /**
1165 * @tc.name: GetGroupIdExt_001
1166 * @tc.desc: return ERR_DM_FAILED
1167 * @tc.type: FUNC
1168 * @tc.require: AR000GHSJK
1169 */
1170 HWTEST_F(HichainConnectorTest, GetGroupIdExt_001, testing::ext::TestSize.Level0)
1171 {
1172 std::string userId = "12";
1173 int32_t groupType = 1;
1174 std::string groupId;
1175 std::string groupOwner;
1176 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1177 int32_t ret = hiChainConnector->GetGroupIdExt(userId, groupType, groupId, groupOwner);
1178 EXPECT_EQ(ret, ERR_DM_FAILED);
1179 }
1180
1181 /**
1182 * @tc.name: ParseRemoteCredentialExt_001
1183 * @tc.desc: return ERR_DM_FAILED
1184 * @tc.type: FUNC
1185 * @tc.require: AR000GHSJK
1186 */
1187 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_001, testing::ext::TestSize.Level0)
1188 {
1189 std::string credentialInfo;
1190 std::string params;
1191 std::string groupOwner;
1192 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1193 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1194 EXPECT_EQ(ret, ERR_DM_FAILED);
1195 }
1196
1197 /**
1198 * @tc.name: ParseRemoteCredentialExt_002
1199 * @tc.desc: return ERR_DM_FAILED
1200 * @tc.type: FUNC
1201 * @tc.require: AR000GHSJK
1202 */
1203 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_002, testing::ext::TestSize.Level0)
1204 {
1205 nlohmann::json jsonObj;
1206 std::string credentialInfo = jsonObj.dump();
1207 std::string params;
1208 std::string groupOwner;
1209 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1210 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1211 EXPECT_EQ(ret, ERR_DM_FAILED);
1212 }
1213
1214 /**
1215 * @tc.name: ParseRemoteCredentialExt_003
1216 * @tc.desc: return ERR_DM_FAILED
1217 * @tc.type: FUNC
1218 * @tc.require: AR000GHSJK
1219 */
1220 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_003, testing::ext::TestSize.Level0)
1221 {
1222 nlohmann::json jsonObj;
1223 jsonObj["authType"] = 1;
1224 jsonObj[FIELD_USER_ID] = "156103";
1225 std::string credentialInfo = jsonObj.dump();
1226 std::string params;
1227 std::string groupOwner;
1228 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1229 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1230 EXPECT_EQ(ret, ERR_DM_FAILED);
1231 }
1232
1233 /**
1234 * @tc.name: ParseRemoteCredentialExt_004
1235 * @tc.desc: return ERR_DM_FAILED
1236 * @tc.type: FUNC
1237 * @tc.require: AR000GHSJK
1238 */
1239 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_004, testing::ext::TestSize.Level0)
1240 {
1241 nlohmann::json jsonObj;
1242 jsonObj["authType"] = 4;
1243 jsonObj[FIELD_USER_ID] = "156103";
1244 std::string credentialInfo = jsonObj.dump();
1245 std::string params;
1246 std::string groupOwner;
1247 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1248 int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1249 EXPECT_EQ(ret, ERR_DM_FAILED);
1250 }
1251
1252 /**
1253 * @tc.name: addMultiMembersExt_001
1254 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1255 * @tc.type: FUNC
1256 * @tc.require: AR000GHSJK
1257 */
1258 HWTEST_F(HichainConnectorTest, addMultiMembersExt_001, testing::ext::TestSize.Level0)
1259 {
1260 std::string credentialInfo;
1261 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1262 hiChainConnector->deviceGroupManager_ = nullptr;
1263 int32_t ret = hiChainConnector->addMultiMembersExt(credentialInfo);
1264 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1265 }
1266
1267 /**
1268 * @tc.name: addMultiMembersExt_002
1269 * @tc.desc: return ERR_DM_FAILED
1270 * @tc.type: FUNC
1271 * @tc.require: AR000GHSJK
1272 */
1273 HWTEST_F(HichainConnectorTest, addMultiMembersExt_002, testing::ext::TestSize.Level0)
1274 {
1275 nlohmann::json jsonObj;
1276 std::string credentialInfo = jsonObj.dump();
1277 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1278 int32_t ret = hiChainConnector->addMultiMembersExt(credentialInfo);
1279 EXPECT_EQ(ret, ERR_DM_FAILED);
1280 }
1281
1282 /**
1283 * @tc.name: GetTrustedDevices_001
1284 * @tc.desc: return true
1285 * @tc.type: FUNC
1286 * @tc.require: AR000GHSJK
1287 */
1288 HWTEST_F(HichainConnectorTest, GetTrustedDevices_001, testing::ext::TestSize.Level0)
1289 {
1290 std::string localDeviceUdid;
1291 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1292 auto ret = hiChainConnector->GetTrustedDevices(localDeviceUdid);
1293 EXPECT_EQ(ret.empty(), true);
1294 }
1295
1296 /**
1297 * @tc.name: GetTrustedDevicesUdid_001
1298 * @tc.desc: return ERR_DM_FAILED
1299 * @tc.type: FUNC
1300 * @tc.require: AR000GHSJK
1301 */
1302 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_001, testing::ext::TestSize.Level0)
1303 {
1304 std::string jsonStr;
1305 std::vector<std::string> udidList;
1306 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1307 int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr.c_str(), udidList);
1308 EXPECT_EQ(ret, ERR_DM_FAILED);
1309 }
1310
1311 /**
1312 * @tc.name: GetTrustedDevicesUdid_002
1313 * @tc.desc: return DM_OK
1314 * @tc.type: FUNC
1315 * @tc.require: AR000GHSJK
1316 */
1317 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_002, testing::ext::TestSize.Level0)
1318 {
1319 nlohmann::json jsonObj;
1320 std::string jsonStr = jsonObj.dump();
1321 std::vector<std::string> udidList;
1322 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1323 int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr.c_str(), udidList);
1324 EXPECT_EQ(ret, DM_OK);
1325 }
1326
1327 /**
1328 * @tc.name: GetTrustedDevicesUdid_003
1329 * @tc.desc: Verify that the function returns DM_OK and correctly populates the udidList.
1330 * @tc.type: FUNC
1331 * @tc.require: AR000GHSJK
1332 */
1333 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_003, testing::ext::TestSize.Level0)
1334 {
1335 const char* jsonStr = R"({
1336 "device1": {
1337 "authId": "valid_udid_1"
1338 },
1339 "device2": {
1340 "authId": 12345
1341 },
1342 "device3": {
1343 "authId": "valid_udid_2"
1344 }
1345 })";
1346
1347 std::vector<std::string> udidList;
1348 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1349 int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr, udidList);
1350 EXPECT_EQ(ret, DM_OK);
1351
1352 std::vector<std::string> expectedUdidList = {"valid_udid_1", "valid_udid_2"};
1353 EXPECT_EQ(udidList, expectedUdidList);
1354 }
1355
1356 /**
1357 * @tc.name: DeleteAllGroup_001
1358 * @tc.type: FUNC
1359 * @tc.require: AR000GHSJK
1360 */
1361 HWTEST_F(HichainConnectorTest, DeleteAllGroup_001, testing::ext::TestSize.Level0)
1362 {
1363 int32_t userId = 1;
1364 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1365 hiChainConnector->DeleteAllGroup(userId);
1366 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1367 }
1368
1369 /**
1370 * @tc.name: DeleteP2PGroup_001
1371 * @tc.type: FUNC
1372 * @tc.require: AR000GHSJK
1373 */
1374 HWTEST_F(HichainConnectorTest, DeleteP2PGroup_001, testing::ext::TestSize.Level0)
1375 {
1376 int32_t userId = 1;
1377 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1378 hiChainConnector->DeleteP2PGroup(userId);
1379 EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1380 }
1381
1382 /**
1383 * @tc.name: GetRelatedGroupsCommon_001
1384 * @tc.desc: return ERR_DM_FAILED
1385 * @tc.type: FUNC
1386 * @tc.require: AR000GHSJK
1387 */
1388 HWTEST_F(HichainConnectorTest, GetRelatedGroupsCommon_001, testing::ext::TestSize.Level0)
1389 {
1390 std::string deviceId;
1391 std::string pkgName;
1392 std::vector<GroupInfo> groupList;
1393 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1394 int32_t ret = hiChainConnector->GetRelatedGroupsCommon(deviceId, pkgName.c_str(), groupList);
1395 EXPECT_EQ(ret, ERR_DM_FAILED);
1396 }
1397 } // namespace
1398 } // namespace DistributedHardware
1399 } // namespace OHOS
1400