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