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