1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "UTTest_hichain_connector.h"
17
18 #include <cstdlib>
19 #include <ctime>
20 #include <functional>
21 #include <securec.h>
22
23 #include "parameter.h"
24 #include "dm_anonymous.h"
25 #include "dm_log.h"
26 #include "dm_constants.h"
27 #include "dm_random.h"
28 #include "hichain_connector.h"
29 #include "device_manager_service_listener.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 namespace {
46 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
47 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
48 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
49 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
50 std::shared_ptr<DmAuthManager> discoveryMgr =
51 std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
52
53 /**
54 * @tc.name: GetRandomData_001
55 * @tc.desc: Set the randStr to GetRandomData to NULlptr and return ERR_DM_FAILED
56 * @tc.type: FUNC
57 * @tc.require: AR000GHSJK
58 */
59 HWTEST_F(HichainConnectorTest, GetRandomData_001, testing::ext::TestSize.Level0)
60 {
61 int32_t ret = 0;
62 ret = GetRandomData(nullptr, 10);
63 EXPECT_EQ(ret, ERR_DM_FAILED);
64 }
65
66 /**
67 * @tc.name: GetRandomData_002
68 * @tc.desc: Set the len to GetRandomData to 0 and return ERR_DM_FAILED
69 * @tc.type: FUNC
70 * @tc.require: AR000GHSJK
71 */
72 HWTEST_F(HichainConnectorTest, GetRandomData_002, testing::ext::TestSize.Level0)
73 {
74 uint8_t randStr[10];
75 uint32_t len = 0;
76 int32_t ret = 0;
77 ret = GetRandomData(randStr, len);
78 EXPECT_EQ(ret, ERR_DM_FAILED);
79 }
80
81 /**
82 * @tc.name: GetRandomData_003
83 * @tc.desc: Set the len and to GetRandomData to 0 and return ERR_DM_FAILED
84 * @tc.type: FUNC
85 * @tc.require: AR000GHSJK
86 */
87 HWTEST_F(HichainConnectorTest, GetRandomData_003, testing::ext::TestSize.Level0)
88 {
89 uint32_t len = 0;
90 int32_t ret = 0;
91 ret = GetRandomData(nullptr, len);
92 EXPECT_EQ(ret, ERR_DM_FAILED);
93 }
94
95 /**
96 * @tc.name: GetRandomData_004
97 * @tc.desc: Set the randStr to GetRandomData to 10 ,set the len to GetRandomData to 10 and return ERR_DM_FAILED
98 * @tc.type: FUNC
99 * @tc.require: AR000GHSJK
100 */
101 HWTEST_F(HichainConnectorTest, GetRandomData_004, testing::ext::TestSize.Level0)
102 {
103 uint8_t randStr[10];
104 uint32_t len = 10;
105 int32_t ret = 0;
106 ret = GetRandomData(randStr, len);
107 EXPECT_EQ(ret, DM_OK);
108 EXPECT_EQ(sizeof(randStr), len);
109 }
110
111 /**
112 * @tc.name: CreateGroup_001
113 * @tc.desc: Set the deviceGroupManager_ pointer to CreateGroup to NULlptr and return ERR_DM_INPUT_PARA_INVALID
114 * @tc.type: FUNC
115 * @tc.require: AR000GHSJK
116 */
117 HWTEST_F(HichainConnectorTest, CreateGroup_001, testing::ext::TestSize.Level0)
118 {
119 int64_t requestId = 123456;
120 std::string groupName = "dfggg";
121 hiChainConnector->deviceGroupManager_ = nullptr;
122 int ret = hiChainConnector->CreateGroup(requestId, groupName);
123 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
124 }
125
126 /**
127 * @tc.name: CreateGroup_002
128 * @tc.desc: Set CreateGroup to the correct process and return DM_OK
129 * @tc.type: FUNC
130 * @tc.require: AR000GHSJK
131 */
132 HWTEST_F(HichainConnectorTest, CreateGroup_002, testing::ext::TestSize.Level0)
133 {
134 int64_t requestId = 123456;
135 std::string groupName = "uuiioo";
136 int ret = hiChainConnector->CreateGroup(requestId, groupName);
137 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
138 }
139
140 /**
141 * @tc.name: CreateGroup_003
142 * @tc.desc: Set deviceGroupManager_ is nullptr return ERR_DM_INPUT_PARA_INVALID
143 * @tc.type: FUNC
144 * @tc.require: AR000GHSJK
145 */
146 HWTEST_F(HichainConnectorTest, CreateGroup_003, testing::ext::TestSize.Level0)
147 {
148 int64_t requestId = 159357;
149 int32_t authType = 1;
150 std::string userId = "userIdTest";
151 nlohmann::json jsonOutObj;
152 hiChainConnector->deviceGroupManager_ = nullptr;
153 int32_t ret = hiChainConnector->CreateGroup(requestId, authType, userId, jsonOutObj);
154 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
155 }
156
157 /**
158 * @tc.name: IsGroupInfoInvalid_001
159 * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is not GROUP_VISIBILITY_PUBLIC.
160 Group.return true
161 * @tc.type: FUNC
162 * @tc.require: AR000GHSJK
163 */
164
165 HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_001, testing::ext::TestSize.Level0)
166 {
167 GroupInfo group;
168 group.groupName = "dkdkkdkdk";
169 group.groupId = 1;
170 group.groupOwner = "ohos.distributedhardware.devicemanager";
171 group.groupType = 7;
172 group.groupVisibility = 1;
173 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
174 bool ret = hiChainConnector->IsGroupInfoInvalid(group);
175 EXPECT_EQ(ret, false);
176 }
177
178 /**
179 * @tc.name: IsGroupInfoInvalid_002
180 * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is GROUP_VISIBILITY_PUBLIC,
181 Grou. groupOwner is not equal to DM_PKG_NAME. The value is true
182 * @tc.type: FUNC
183 * @tc.require: AR000GHSJK
184 */
185 HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_002, testing::ext::TestSize.Level0)
186 {
187 GroupInfo group;
188 group.groupName = "test";
189 group.groupId = 1;
190 group.groupOwner = "ohos.disware";
191 group.groupType = 1;
192 group.groupVisibility = -1;
193 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
194 bool ret = hichainConnector->IsGroupInfoInvalid(group);
195 EXPECT_EQ(ret, true);
196 }
197
198 /**
199 * @tc.name: DelMemberFromGroup_001
200 * @tc.desc:set groupId, deviceId null and return DM_OK
201 * @tc.type: FUNC
202 * @tc.require: AR000GHSJK
203 */
204 HWTEST_F(HichainConnectorTest, DelMemberFromGroup_001, testing::ext::TestSize.Level0)
205 {
206 std::string groupId;
207 std::string deviceId;
208 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
209 int ret = hichainConnector->DelMemberFromGroup(groupId, deviceId);
210 EXPECT_NE(ret, -1);
211 }
212
213 /**
214 * @tc.name: DelMemberFromGroup_002
215 * @tc.desc: The groupId "34451"; The deviceId = "123"; Can be deleted correctly
216 * @tc.type: FUNC
217 * @tc.require: AR000GHSJK
218 */
219 HWTEST_F(HichainConnectorTest, DelMemberFromGroup_002, testing::ext::TestSize.Level0)
220 {
221 std::string groupId = "34451";
222 std::string deviceId = "123";
223 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
224 int ret = hichainConnector->DelMemberFromGroup(groupId, deviceId);
225 EXPECT_NE(ret, -1);
226 }
227
228 /**
229 * @tc.name: GenRequestId_001
230 * @tc.desc:Call the GenRequestId function
231 * @tc.type: FUNC
232 * @tc.require: AR000GHSJK
233 */
234 HWTEST_F(HichainConnectorTest, GenRequestId_001, testing::ext::TestSize.Level0)
235 {
236 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
237 int ret = hichainConnector->GenRequestId();
238 ASSERT_NE(ret, 0);
239 }
240
241 /**
242 * @tc.name: from_json_001
243 * @tc.desc: Pass in arguments to the from_JSON function and convert it to the correct value
244 * @tc.type: FUNC
245 * @tc.require: AR000GHSJK
246 */
247 HWTEST_F(HichainConnectorTest, from_json_001, testing::ext::TestSize.Level0)
248 {
249 GroupInfo groupInfo;
250 groupInfo.groupName = "aaaa";
251 groupInfo.groupId = "345678";
252 groupInfo.groupOwner = "lllll";
253 groupInfo.groupType = 5;
254 groupInfo.groupVisibility = 5;
255 nlohmann::json jsonObject;
256 jsonObject[FIELD_GROUP_NAME] = groupInfo.groupName;
257 jsonObject[FIELD_GROUP_ID] = groupInfo.groupId;
258 jsonObject[FIELD_GROUP_OWNER] = groupInfo.groupOwner;
259 jsonObject[FIELD_GROUP_TYPE] = groupInfo.groupType;
260 jsonObject[FIELD_GROUP_VISIBILITY] = groupInfo.groupVisibility;
261 from_json(jsonObject, groupInfo);
262 EXPECT_EQ(groupInfo.groupName, "aaaa");
263 EXPECT_EQ(groupInfo.groupId, "345678");
264 EXPECT_EQ(groupInfo.groupOwner, "lllll");
265 EXPECT_EQ(groupInfo.groupType, 5);
266 EXPECT_EQ(groupInfo.groupVisibility, 5);
267 }
268
269 /**
270 * @tc.name: HiChainConnector_001
271 * @tc.desc: Returns a new pointer to the HiChainConnector constructor new
272 * @tc.type: FUNC
273 * @tc.require: AR000GHSJK
274 */
275 HWTEST_F(HichainConnectorTest, HiChainConnector_001, testing::ext::TestSize.Level0)
276 {
277 std::shared_ptr<HiChainConnector> m_HiChainConnector = std::make_shared<HiChainConnector>();
278 ASSERT_NE(m_HiChainConnector, nullptr);
279 }
280
281 /**
282 * @tc.name: HiChainConnector_002
283 * @tc.desc: Give the HiChainConnector constructor new a new pointer and delete it
284 * @tc.type: FUNC
285 * @tc.require: AR000GHSJK
286 */
287 HWTEST_F(HichainConnectorTest, HiChainConnector_002, testing::ext::TestSize.Level0)
288 {
289 std::shared_ptr<HiChainConnector> m_HiChainConnector = std::make_shared<HiChainConnector>();
290 m_HiChainConnector.reset();
291 EXPECT_EQ(m_HiChainConnector, nullptr);
292 }
293
294 /**
295 * @tc.name:RegisterHiChainCallback_001
296 * @tc.desc: Call the RegisterHiChainCallback function with a return value of DM_OK
297 * @tc.type: FUNC
298 * @tc.require: AR000GHSJK
299 */
300 HWTEST_F(HichainConnectorTest, RegisterHiChainCallback_001, testing::ext::TestSize.Level0)
301 {
302 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
303 int ret = hichainConnector->RegisterHiChainCallback(std::shared_ptr<IHiChainConnectorCallback>(discoveryMgr));
304 EXPECT_EQ(ret, DM_OK);
305 }
306
307 /**
308 * @tc.name: AddMember_001
309 * @tc.desc: set deviceGroupManager_ = nullptr;
310 * @tc.type: FUNC
311 * @tc.require: AR000GHSJK
312 */
313 HWTEST_F(HichainConnectorTest, AddMember_001, testing::ext::TestSize.Level0)
314 {
315 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
316 hichainConnector->deviceGroupManager_ = nullptr;
317 std::string deviceId;
318 std::string connectInfo;
319 int ret = hichainConnector->AddMember(deviceId, connectInfo);
320 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
321 }
322
323 /**
324 * @tc.name: AddMember_002
325 * @tc.desc: set deviceId and connectInfo = null;
326 * @tc.type: FUNC
327 * @tc.require: AR000GHSJK
328 */
329 HWTEST_F(HichainConnectorTest, AddMember_002, testing::ext::TestSize.Level0)
330 {
331 std::string deviceId;
332 std::string connectInfo;
333 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
334 int ret = hichainConnector->AddMember(deviceId, connectInfo);
335 EXPECT_EQ(ret, ERR_DM_FAILED);
336 }
337
338 /**
339 * @tc.name: AddMember_003
340 * @tc.desc: set deviceId and connectInfo = null;
341 * @tc.type: FUNC
342 * @tc.require: AR000GHSJK
343 */
344 HWTEST_F(HichainConnectorTest, AddMember_003, testing::ext::TestSize.Level0)
345 {
346 std::string deviceId = "123456";
347 std::string connectInfo = "dkdkk";
348 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
349 int ret = hichainConnector->AddMember(deviceId, connectInfo);
350 ASSERT_LE(ret, 1);
351 }
352
353 /**
354 * @tc.name: AddMember_004
355 * @tc.desc: set deviceId and connectInfo = null;
356 * @tc.type: FUNC
357 * @tc.require: AR000GHSJK
358 */
359 HWTEST_F(HichainConnectorTest, AddMember_004, testing::ext::TestSize.Level0)
360 {
361 std::string deviceId = "deviceIdTest";
362 std::string connectInfo = R"(
363 {
364 "DEVICEID" : "deviceId",
365 "pinCode" : 1,
366 "groupId" : "groupId",
367 "REQUESTID" : "requestId",
368 "GROUPNAME" : "groupName"
369 }
370 )";
371 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
372 int32_t ret = hichainConnector->AddMember(deviceId, connectInfo);
373 EXPECT_EQ(ret, ERR_DM_FAILED);
374 }
375
376 /**
377 * @tc.name: onRequest_001
378 * @tc.desc:set operationCode != GroupOperationCode::MEMBER_JOIN(3); return nullptr;
379 * @tc.require: AR000GHSJK
380 */
381 HWTEST_F(HichainConnectorTest, onRequest_001, testing::ext::TestSize.Level0)
382 {
383 int64_t requestId = 2;
384 int32_t operationCode = 2;
385 char *reqParams;
386 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
387 char *ret = hichainConnector->onRequest(requestId, operationCode, reqParams);
388 EXPECT_EQ(ret, nullptr);
389 }
390
391 /**
392 * @tc.name: onRequest_002
393 * @tc.desc: operationCode = GroupOperationCode::MEMBER_JOIN(3)/hiChainConnectorCallback_ is nullptr; return nullptr;
394 * @tc.require: AR000GHSJK
395 */
396 HWTEST_F(HichainConnectorTest, onRequest_002, testing::ext::TestSize.Level0)
397 {
398 int64_t requestId = 2;
399 int32_t operationCode = 3;
400 char *reqParams;
401 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
402 hichainConnector->hiChainConnectorCallback_ = nullptr;
403 char *ret = hichainConnector->onRequest(requestId, operationCode, reqParams);
404 EXPECT_EQ(ret, nullptr);
405 }
406
407 /**
408 * @tc.name: GetConnectPara_001
409 * @tc.desc: set para not null and go to the second branch
410 * @tc.type: FUNC
411 * @tc.require: AR000GHSJK
412 */
413 HWTEST_F(HichainConnectorTest, GetConnectPara_001, testing::ext::TestSize.Level0)
414 {
415 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
416 hichainConnector->RegisterHiChainCallback(std::shared_ptr<IHiChainConnectorCallback>(discoveryMgr));
417 std::string deviceId = "23445";
418 std::string reqDeviceId = "234566";
419 std::string p;
420 std::string ret = hichainConnector->GetConnectPara(deviceId, reqDeviceId);
421 EXPECT_EQ(ret, p);
422 }
423
424 /**
425 * @tc.name: GetConnectPara_002
426 * @tc.desc:Empty deviceId so that jsonObject.is_discarded is null and the value of connectAddr is returned
427 * @tc.type: FUNC
428 * @tc.require: AR000GHSJK
429 */
430 HWTEST_F(HichainConnectorTest, GetConnectPara_002, testing::ext::TestSize.Level0)
431 {
432 std::string deviceId;
433 std::string reqDeviceId = "234566";
434 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
435 hichainConnector->RegisterHiChainCallback(std::shared_ptr<IHiChainConnectorCallback>(discoveryMgr));
436 std::string ret = hichainConnector->GetConnectPara(deviceId, reqDeviceId);
437 EXPECT_EQ(ret, "");
438 }
439
440 /**
441 * @tc.name: GetConnectPara_003
442 * @tc.desc: hiChainConnectorCallback_ is nullptr return ""
443 * @tc.type: FUNC
444 * @tc.require: AR000GHSJK
445 */
446 HWTEST_F(HichainConnectorTest, GetConnectPara_003, testing::ext::TestSize.Level0)
447 {
448 std::string deviceId = "deviceIdTest";
449 std::string reqDeviceId = "11369";
450 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
451 hichainConnector->hiChainConnectorCallback_ = nullptr;
452 std::string ret = hichainConnector->GetConnectPara(deviceId, reqDeviceId);
453 EXPECT_EQ(ret, "");
454 }
455
456 /**
457 * @tc.name: DeleteGroup_001
458 * @tc.desc: set groupId = "34567", and return DM_OK
459 * @tc.type: FUNC
460 * @tc.require: AR000GHSJK
461 */
462 HWTEST_F(HichainConnectorTest, DeleteGroup_001, testing::ext::TestSize.Level0)
463 {
464 std::string groupId = "34567";
465 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
466 int ret = hichainConnector->DeleteGroup(groupId);
467 EXPECT_NE(ret, -1);
468 }
469
470 /**
471 * @tc.name: GetRelatedGroups_001
472 * @tc.desc: set DeviceId 123 groupList null and return ERR_DM_FAILED
473 * @tc.type: FUNC
474 * @tc.require: AR000GHSJK
475 */
476 HWTEST_F(HichainConnectorTest, GetRelatedGroups_001, testing::ext::TestSize.Level0)
477 {
478 std::string DeviceId = "123";
479 std::vector<GroupInfo> groupList;
480 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
481 int ret = hichainConnector->GetRelatedGroups(DeviceId, groupList);
482 EXPECT_EQ(ret, ERR_DM_FAILED);
483 }
484
485 /**
486 * @tc.name: GetRelatedGroups_002
487 * @tc.desc: set DeviceId = 12345,groupList null and return ERR_DM_FAILED
488 * @tc.type: FUNC
489 * @tc.require: AR000GHSJK
490 */
491 HWTEST_F(HichainConnectorTest, GetRelatedGroups_002, testing::ext::TestSize.Level0)
492 {
493 std::string DeviceId = "12345";
494 std::vector<GroupInfo> groupList;
495 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
496 int ret = hichainConnector->GetRelatedGroups(DeviceId, groupList);
497 EXPECT_EQ(ret, ERR_DM_FAILED);
498 }
499
500 /**
501 * @tc.name: SyncGroups_001
502 * @tc.desc: set deviceId = "34567", and return DM_OK
503 * @tc.type: FUNC
504 * @tc.require: AR000GHSJK
505 */
506 HWTEST_F(HichainConnectorTest, SyncGroups_001, testing::ext::TestSize.Level0)
507 {
508 std::string deviceId = "34567";
509 std::vector<std::string> remoteGroupIdList;
510 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
511 int ret = hichainConnector->SyncGroups(deviceId, remoteGroupIdList);
512 EXPECT_EQ(ret, DM_OK);
513 }
514
515 /**
516 * @tc.name: GetSyncGroupList_001
517 * @tc.desc: set groupList null, and return ERR_DM_FAILED
518 * @tc.type: FUNC
519 * @tc.require: AR000GHSJK
520 */
521 HWTEST_F(HichainConnectorTest, GetSyncGroupList_001, testing::ext::TestSize.Level0)
522 {
523 std::vector<GroupInfo> groupList;
524 std::vector<std::string> syncGroupList;
525 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
526 int ret = hichainConnector->GetSyncGroupList(groupList, syncGroupList);
527 EXPECT_EQ(ret, ERR_DM_FAILED);
528 }
529
530 /**
531 * @tc.name: GetSyncGroupList_002
532 * @tc.desc: set groupList not null, and return DM_OK
533 * @tc.type: FUNC
534 * @tc.require: AR000GHSJK
535 */
536 HWTEST_F(HichainConnectorTest, GetSyncGroupList_002, testing::ext::TestSize.Level0)
537 {
538 std::vector<GroupInfo> groupList;
539 GroupInfo groupList1;
540 groupList1.groupName = "hichainconnector";
541 groupList1.groupId = "123456";
542 groupList1.groupOwner = "doftbus";
543 groupList1.groupType = 1;
544 groupList1.groupVisibility = 2;
545 groupList.push_back(groupList1);
546 std::vector<std::string> syncGroupList;
547 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
548 int ret = hichainConnector->GetSyncGroupList(groupList, syncGroupList);
549 EXPECT_EQ(ret, DM_OK);
550 }
551
552 /**
553 * @tc.name: IsGroupCreated_001
554 * @tc.desc: return false
555 * @tc.type: FUNC
556 * @tc.require: AR000GHSJK
557 */
558 HWTEST_F(HichainConnectorTest, IsGroupCreated_001, testing::ext::TestSize.Level0)
559 {
560 std::string groupName = "groupNameTest";
561 GroupInfo groupInfo;
562 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
563 bool ret = hichainConnector->IsGroupCreated(groupName, groupInfo);
564 EXPECT_EQ(ret, false);
565 }
566
567 /**
568 * @tc.name: IsRedundanceGroup_001
569 * @tc.desc: return false
570 * @tc.type: FUNC
571 * @tc.require: AR000GHSJK
572 */
573 HWTEST_F(HichainConnectorTest, IsRedundanceGroup_001, testing::ext::TestSize.Level0)
574 {
575 const std::string userId = "userIdTest";
576 int32_t authType = 1;
577 std::vector<GroupInfo> groupList;
578 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
579 bool ret = hichainConnector->IsRedundanceGroup(userId, authType, groupList);
580 EXPECT_EQ(ret, false);
581 }
582
583 /**
584 * @tc.name: onFinish_001
585 * @tc.desc: return DM_OK
586 * @tc.type: FUNC
587 * @tc.require: AR000GHSJK
588 */
589 HWTEST_F(HichainConnectorTest, onFinish_001, testing::ext::TestSize.Level0)
590 {
591 int64_t requestId = 1;
592 int operationCode = GroupOperationCode::MEMBER_JOIN;
593 const char *returnData = "returnDataTest";
594 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
595 int32_t ret = hichainConnector->RegisterHiChainCallback(std::shared_ptr<IHiChainConnectorCallback>(discoveryMgr));
596
597 hichainConnector->onFinish(requestId, operationCode, returnData);
598
599 operationCode = GroupOperationCode::GROUP_CREATE;
600 hichainConnector->onFinish(requestId, operationCode, returnData);
601
602 operationCode = GroupOperationCode::MEMBER_DELETE;
603 hichainConnector->onFinish(requestId, operationCode, returnData);
604
605 operationCode = GroupOperationCode::GROUP_DISBAND;
606 hichainConnector->onFinish(requestId, operationCode, returnData);
607 EXPECT_EQ(ret, DM_OK);
608 }
609
610 /**
611 * @tc.name: onError_001
612 * @tc.desc: return DM_OK
613 * @tc.type: FUNC
614 * @tc.require: AR000GHSJK
615 */
616 HWTEST_F(HichainConnectorTest, onError_001, testing::ext::TestSize.Level0)
617 {
618 int64_t requestId = 1;
619 int operationCode = GroupOperationCode::MEMBER_JOIN;
620 int errorCode = 1;
621 const char *errorReturn = "errorReturnTest";
622 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
623 int32_t ret = hichainConnector->RegisterHiChainCallback(std::shared_ptr<IHiChainConnectorCallback>(discoveryMgr));
624 hichainConnector->onError(requestId, operationCode, errorCode, errorReturn);
625
626 operationCode = GroupOperationCode::GROUP_CREATE;
627 hichainConnector->onError(requestId, operationCode, errorCode, errorReturn);
628
629 operationCode = GroupOperationCode::MEMBER_DELETE;
630 hichainConnector->onError(requestId, operationCode, errorCode, errorReturn);
631
632 operationCode = GroupOperationCode::GROUP_DISBAND;
633 hichainConnector->onError(requestId, operationCode, errorCode, errorReturn);
634 EXPECT_EQ(ret, DM_OK);
635 }
636
637 /**
638 * @tc.name: DeleteGroup_002
639 * @tc.desc: return ERR_DM_FAILED
640 * @tc.type: FUNC
641 * @tc.require: AR000GHSJK
642 */
643 HWTEST_F(HichainConnectorTest, DeleteGroup_002, testing::ext::TestSize.Level0)
644 {
645 const int32_t userId = 1;
646 std::string groupId = "groupIdTest";
647 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
648 int32_t ret = hichainConnector->DeleteGroup(userId, groupId);
649 EXPECT_EQ(ret, ERR_DM_FAILED);
650 }
651
652 /**
653 * @tc.name: DeleteGroup_003
654 * @tc.desc: return ERR_DM_FAILED
655 * @tc.type: FUNC
656 * @tc.require: AR000GHSJK
657 */
658 HWTEST_F(HichainConnectorTest, DeleteGroup_003, testing::ext::TestSize.Level0)
659 {
660 int64_t requestId = 1;
661 std::string userId = "userIdTest";
662 const int32_t authType = 1;
663 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
664 hichainConnector->DeleteRedundanceGroup(userId);
665 int32_t ret = hichainConnector->DeleteGroup(requestId, userId, authType);
666 EXPECT_EQ(ret, ERR_DM_FAILED);
667 }
668
669 /**
670 * @tc.name: RegisterHiChainGroupCallback_001
671 * @tc.desc: return DM_OK
672 * @tc.type: FUNC
673 * @tc.require: AR000GHSJK
674 */
675 HWTEST_F(HichainConnectorTest, RegisterHiChainGroupCallback_001, testing::ext::TestSize.Level0)
676 {
677 std::shared_ptr<IDmGroupResCallback> callback = nullptr;
678 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
679 int32_t ret = hichainConnector->RegisterHiChainGroupCallback(callback);
680 EXPECT_EQ(ret, DM_OK);
681 }
682
683 /**
684 * @tc.name: UnRegisterHiChainGroupCallback_001
685 * @tc.desc: return DM_OK
686 * @tc.type: FUNC
687 * @tc.require: AR000GHSJK
688 */
689 HWTEST_F(HichainConnectorTest, UnRegisterHiChainGroupCallback_001, testing::ext::TestSize.Level0)
690 {
691 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
692 int32_t ret = hichainConnector->UnRegisterHiChainGroupCallback();
693 EXPECT_EQ(ret, DM_OK);
694 }
695
696 /**
697 * @tc.name: getRegisterInfo_001
698 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
699 * @tc.type: FUNC
700 * @tc.require: AR000GHSJK
701 */
702 HWTEST_F(HichainConnectorTest, getRegisterInfo_001, testing::ext::TestSize.Level0)
703 {
704 std::string queryParams;
705 std::string returnJsonStr;
706 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
707 hichainConnector->deviceGroupManager_ = nullptr;
708 int32_t ret = hichainConnector->getRegisterInfo(queryParams, returnJsonStr);
709 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
710 }
711
712 /**
713 * @tc.name: ParseRemoteCredential_001
714 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
715 * @tc.type: FUNC
716 * @tc.require: AR000GHSJK
717 */
718 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_001, testing::ext::TestSize.Level0)
719 {
720 int32_t groupType = 1;
721 std::string userId = "";
722 nlohmann::json jsonDeviceList;
723 std::string params = "paramsTest";
724 int32_t osAccountUserId = 0;
725 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
726 int32_t ret = hichainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
727 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
728 }
729
730 /**
731 * @tc.name: addMultiMembers_001
732 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
733 * @tc.type: FUNC
734 * @tc.require: AR000GHSJK
735 */
736 HWTEST_F(HichainConnectorTest, addMultiMembers_001, testing::ext::TestSize.Level0)
737 {
738 int32_t groupType = 1;
739 std::string userId = "";
740 nlohmann::json jsonDeviceList;
741 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
742 hichainConnector->deviceGroupManager_ = nullptr;
743 int32_t ret = hichainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
744 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
745 }
746
747 /**
748 * @tc.name: addMultiMembers_002
749 * @tc.desc: return ERR_DM_FAILED
750 * @tc.type: FUNC
751 * @tc.require: AR000GHSJK
752 */
753 HWTEST_F(HichainConnectorTest, addMultiMembers_002, testing::ext::TestSize.Level0)
754 {
755 int32_t groupType = 1;
756 std::string userId = "userIdTest";
757 nlohmann::json jsonDeviceList;
758 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
759 EXPECT_NE(hichainConnector->deviceGroupManager_, nullptr);
760 int32_t ret = hichainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
761 EXPECT_EQ(ret, ERR_DM_FAILED);
762 }
763
764 /**
765 * @tc.name: deleteMultiMembers_001
766 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
767 * @tc.type: FUNC
768 * @tc.require: AR000GHSJK
769 */
770 HWTEST_F(HichainConnectorTest, deleteMultiMembers_001, testing::ext::TestSize.Level0)
771 {
772 int32_t groupType = 1;
773 std::string userId = "userIdTest";
774 nlohmann::json jsonDeviceList;
775 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
776 hichainConnector->deviceGroupManager_ = nullptr;
777 int32_t ret = hichainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
778 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
779 }
780
781 /**
782 * @tc.name: deleteMultiMembers_002
783 * @tc.desc: return ERR_DM_FAILED
784 * @tc.type: FUNC
785 * @tc.require: AR000GHSJK
786 */
787 HWTEST_F(HichainConnectorTest, deleteMultiMembers_002, testing::ext::TestSize.Level0)
788 {
789 int32_t groupType = 1;
790 std::string userId = "";
791 nlohmann::json jsonDeviceList;
792 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
793 EXPECT_NE(hichainConnector->deviceGroupManager_, nullptr);
794 int32_t ret = hichainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
795 EXPECT_EQ(ret, ERR_DM_FAILED);
796 }
797
798 /**
799 * @tc.name: IsDevicesInP2PGroup_001
800 * @tc.desc: return ERR_DM_FAILED
801 * @tc.type: FUNC
802 * @tc.require: AR000GHSJK
803 */
804 HWTEST_F(HichainConnectorTest, IsDevicesInP2PGroup_001, testing::ext::TestSize.Level0)
805 {
806 std::string hostDevice = "hostDeviceTest";
807 std::string peerDevice = "peerDeviceTest";
808 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
809 bool ret = hichainConnector->IsDevicesInP2PGroup(hostDevice, peerDevice);
810 EXPECT_EQ(ret, false);
811 }
812
813 /**
814 * @tc.name: UnRegisterHiChainCallback_001
815 * @tc.desc: return DM_OK
816 * @tc.type: FUNC
817 * @tc.require: AR000GHSJK
818 */
819 HWTEST_F(HichainConnectorTest, UnRegisterHiChainCallback_001, testing::ext::TestSize.Level0)
820 {
821 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
822 int32_t ret = hichainConnector->UnRegisterHiChainCallback();
823 EXPECT_EQ(hichainConnector->hiChainConnectorCallback_, nullptr);
824 EXPECT_EQ(ret, DM_OK);
825 }
826 } // namespace
827 } // namespace DistributedHardware
828 } // namespace OHOS
829