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