1 /*
2 * Copyright (c) 2024-2025 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 <gtest/gtest.h>
17
18 #include "cJSON.h"
19
20 #include "constants.h"
21 #include "dh_utils_tool.h"
22 #include "dh_context.h"
23 #include "distributed_hardware_errno.h"
24 #include "meta_capability_info.h"
25 #include "meta_info_manager.h"
26 #include "task_board.h"
27 #include "impl_utils.h"
28
29 using namespace testing::ext;
30 using namespace std;
31
32 namespace OHOS {
33 namespace DistributedHardware {
34 namespace {
35 constexpr uint16_t DEV_TYPE_TEST = 14;
36 constexpr uint32_t MAX_DB_RECORD_LENGTH = 10005;
37 }
38
39 class MetaInfoMgrTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUp()47 void MetaInfoMgrTest::SetUp() {}
48
TearDown()49 void MetaInfoMgrTest::TearDown() {}
50
SetUpTestCase()51 void MetaInfoMgrTest::SetUpTestCase() {}
52
TearDownTestCase()53 void MetaInfoMgrTest::TearDownTestCase() {}
54
55 HWTEST_F(MetaInfoMgrTest, Init_001, TestSize.Level1)
56 {
57 auto ret = MetaInfoManager::GetInstance()->Init();
58 EXPECT_EQ(DH_FWK_SUCCESS, ret);
59 ret = MetaInfoManager::GetInstance()->UnInit();
60 EXPECT_EQ(DH_FWK_SUCCESS, ret);
61 }
62
63 HWTEST_F(MetaInfoMgrTest, UnInit_001, TestSize.Level1)
64 {
65 MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
66 auto ret = MetaInfoManager::GetInstance()->UnInit();
67 EXPECT_EQ(ERR_DH_FWK_RESOURCE_UNINIT_DB_FAILED, ret);
68 }
69
70 HWTEST_F(MetaInfoMgrTest, AddMetaCapInfos_001, TestSize.Level1)
71 {
72 std::string udidHash = "udidHash_test";
73 std::vector<std::shared_ptr<MetaCapabilityInfo>> metaCapInfos;
74 auto ret = MetaInfoManager::GetInstance()->AddMetaCapInfos(metaCapInfos);
75 EXPECT_EQ(ERR_DH_FWK_RESOURCE_RES_DB_DATA_INVALID, ret);
76
77 for (int32_t i = 1; i < MAX_DB_RECORD_LENGTH; i++) {
78 std::shared_ptr<MetaCapabilityInfo> mateCapInfoTest = make_shared<MetaCapabilityInfo>(std::to_string(i),
79 std::to_string(i), "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "subtype", udidHash,
80 CompVersion{ .sinkVersion = "1.0" });
81 metaCapInfos.push_back(mateCapInfoTest);
82 }
83 ret = MetaInfoManager::GetInstance()->AddMetaCapInfos(metaCapInfos);
84 EXPECT_EQ(ERR_DH_FWK_RESOURCE_RES_DB_DATA_INVALID, ret);
85 }
86
87 HWTEST_F(MetaInfoMgrTest, AddMetaCapInfos_002, TestSize.Level1)
88 {
89 std::string deviceId = "deviceId_test";
90 std::string udidHash = "udidHash_test";
91 std::string dhId = "dhId_test";
92 CompVersion compVersion;
93 compVersion.sinkVersion = "1.0";
94 std::shared_ptr<MetaCapabilityInfo> metaCapInfo = std::make_shared<MetaCapabilityInfo>(
95 dhId, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs_test", "subtype", udidHash, compVersion);
96 std::vector<std::shared_ptr<MetaCapabilityInfo>> metaCapInfos;
97 metaCapInfos.push_back(metaCapInfo);
98 auto ret = MetaInfoManager::GetInstance()->AddMetaCapInfos(metaCapInfos);
99 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
100
101 MetaInfoManager::GetInstance()->Init();
102 std::shared_ptr<MetaCapabilityInfo> mateCapInfoTest = nullptr;
103 metaCapInfos.push_back(mateCapInfoTest);
104 ret = MetaInfoManager::GetInstance()->AddMetaCapInfos(metaCapInfos);
105 EXPECT_EQ(DH_FWK_SUCCESS, ret);
106 MetaInfoManager::GetInstance()->UnInit();
107 }
108
109 HWTEST_F(MetaInfoMgrTest, SyncMetaInfoFromDB_001, TestSize.Level1)
110 {
111 std::string udidHash = "";
112 auto ret = MetaInfoManager::GetInstance()->SyncMetaInfoFromDB(udidHash);
113 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
114 }
115
116 HWTEST_F(MetaInfoMgrTest, SyncMetaInfoFromDB_002, TestSize.Level1)
117 {
118 std::string udidHash = "132456798";
119 auto ret = MetaInfoManager::GetInstance()->SyncMetaInfoFromDB(udidHash);
120 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
121 }
122
123 HWTEST_F(MetaInfoMgrTest, SyncMetaInfoFromDB_003, TestSize.Level1)
124 {
125 std::string udidHash = "132456798";
126 MetaInfoManager::GetInstance()->Init();
127 auto ret = MetaInfoManager::GetInstance()->SyncMetaInfoFromDB(udidHash);
128 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
129 MetaInfoManager::GetInstance()->UnInit();
130 }
131
132 HWTEST_F(MetaInfoMgrTest, SyncRemoteMetaInfos_001, TestSize.Level1)
133 {
134 auto ret = MetaInfoManager::GetInstance()->SyncRemoteMetaInfos();
135 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
136
137 MetaInfoManager::GetInstance()->Init();
138 ret = MetaInfoManager::GetInstance()->SyncRemoteMetaInfos();
139 EXPECT_EQ(DH_FWK_SUCCESS, ret);
140 MetaInfoManager::GetInstance()->UnInit();
141 }
142
143 HWTEST_F(MetaInfoMgrTest, SyncRemoteMetaInfos_002, TestSize.Level1)
144 {
145 std::string udid = "111111";
146 std::string uuid = "222222";
147 std::string networkId = "333333";
148 DHContext::GetInstance().AddOnlineDevice(udid, uuid, networkId);
149 MetaInfoManager::GetInstance()->Init();
150 auto ret = MetaInfoManager::GetInstance()->SyncRemoteMetaInfos();
151 EXPECT_EQ(DH_FWK_SUCCESS, ret);
152 MetaInfoManager::GetInstance()->UnInit();
153 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(networkId);
154 }
155
156 HWTEST_F(MetaInfoMgrTest, GetDataByKeyPrefix_001, TestSize.Level1)
157 {
158 std::string keyPrefix = "";
159 MetaCapInfoMap metaCapMap;
160 auto ret = MetaInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, metaCapMap);
161 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
162
163 keyPrefix = "keyPrefix_test";
164 ret = MetaInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, metaCapMap);
165 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
166 }
167
168 HWTEST_F(MetaInfoMgrTest, GetDataByKeyPrefix_002, TestSize.Level1)
169 {
170 std::string keyPrefix = "keyPrefix_test";
171 MetaCapInfoMap metaCapMap;
172 MetaInfoManager::GetInstance()->Init();
173 auto ret = MetaInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, metaCapMap);
174 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
175 MetaInfoManager::GetInstance()->UnInit();
176 }
177
178 HWTEST_F(MetaInfoMgrTest, GetMetaCapInfo_001, TestSize.Level1)
179 {
180 std::string udidHash = "";
181 std::string dhId = "";
182 std::shared_ptr<MetaCapabilityInfo> metaCapPtr;
183 auto ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
184 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
185
186 udidHash = "123456789";
187 ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
188 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
189
190 udidHash = "";
191 dhId = "123456789";
192 ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
193 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
194 }
195
196 HWTEST_F(MetaInfoMgrTest, GetMetaCapInfo_002, TestSize.Level1)
197 {
198 std::string deviceId = "deviceId_test";
199 std::string udidHash = "udidHash_test";
200 std::string dhId = "dhId_test";
201 CompVersion compVersion{ .sinkVersion = "1.0" };
202 std::shared_ptr<MetaCapabilityInfo> metaCapPtr;
203 std::shared_ptr<MetaCapabilityInfo> dhMetaCapInfo = std::make_shared<MetaCapabilityInfo>(
204 dhId, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs_test", "subtype", udidHash, compVersion);
205 std::string key = udidHash + "###" + dhId;
206 MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
207 auto ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(deviceId, dhId, metaCapPtr);
208 EXPECT_EQ(ERR_DH_FWK_RESOURCE_CAPABILITY_MAP_NOT_FOUND, ret);
209
210 ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
211 EXPECT_EQ(DH_FWK_SUCCESS, ret);
212 MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
213 }
214
215 HWTEST_F(MetaInfoMgrTest, GetMetaCapInfosByUdidHash_001, TestSize.Level1)
216 {
217 std::string udidHash = "";
218 std::vector<std::shared_ptr<MetaCapabilityInfo>> metaCapInfos;
219 MetaInfoManager::GetInstance()->GetMetaCapInfosByUdidHash(udidHash, metaCapInfos);
220
221 udidHash = "udidHash_test";
222 std::string deviceId = "deviceId_test";
223 std::string dhId = "dhId_test";
224 std::shared_ptr<MetaCapabilityInfo> metaCapInfo = std::make_shared<MetaCapabilityInfo>(
225 dhId, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs_test", "subtype", udidHash,
226 CompVersion{ .sinkVersion = "1.0" });
227 std::string key = udidHash + "###" + dhId;
228 MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = metaCapInfo;
229 MetaInfoManager::GetInstance()->GetMetaCapInfosByUdidHash(deviceId, metaCapInfos);
230 EXPECT_TRUE(metaCapInfos.empty());
231
232 MetaInfoManager::GetInstance()->GetMetaCapInfosByUdidHash(udidHash, metaCapInfos);
233 EXPECT_FALSE(metaCapInfos.empty());
234 MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
235 }
236
237 HWTEST_F(MetaInfoMgrTest, GetMetaCapByValue_001, TestSize.Level1)
238 {
239 std::string value = "";
240 std::shared_ptr<MetaCapabilityInfo> metaCapPtr = nullptr;
241 auto ret = MetaInfoManager::GetInstance()->GetMetaCapByValue(value, metaCapPtr);
242 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
243
244 value = "invalid JSON string";
245 ret = MetaInfoManager::GetInstance()->GetMetaCapByValue(value, metaCapPtr);
246 EXPECT_EQ(ERR_DH_FWK_JSON_PARSE_FAILED, ret);
247
248 std::string deviceId = "deviceId_test";
249 std::string udidHash = "udidHash_test";
250 std::string dhId = "dhId_test";
251 metaCapPtr = std::make_shared<MetaCapabilityInfo>(
252 dhId, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs_test", "subtype", udidHash,
253 CompVersion{ .sinkVersion = "1.0" });
254 ret = MetaInfoManager::GetInstance()->GetMetaCapByValue(value, metaCapPtr);
255 EXPECT_EQ(ERR_DH_FWK_JSON_PARSE_FAILED, ret);
256 }
257
258 HWTEST_F(MetaInfoMgrTest, GetMetaDataByDHType_001, TestSize.Level1)
259 {
260 std::string deviceId = "deviceId_test";
261 std::string udidHash = "udidHash_test";
262 std::string dhId = "dhId_test";
263 MetaCapInfoMap metaInfoMap;
264 std::shared_ptr<MetaCapabilityInfo> dhMetaCapInfo = std::make_shared<MetaCapabilityInfo>(
265 dhId, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs_test", "subtype", udidHash,
266 CompVersion{ .sinkVersion = "1.0" });
267 std::string key = udidHash + "###" + dhId;
268 MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
269 auto ret = MetaInfoManager::GetInstance()->GetMetaDataByDHType(DHType::AUDIO, metaInfoMap);
270 EXPECT_EQ(DH_FWK_SUCCESS, ret);
271
272 ret = MetaInfoManager::GetInstance()->GetMetaDataByDHType(DHType::CAMERA, metaInfoMap);
273 EXPECT_EQ(DH_FWK_SUCCESS, ret);
274 MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
275 }
276
277 HWTEST_F(MetaInfoMgrTest, SyncDataByNetworkId_001, TestSize.Level1)
278 {
279 std::string networkId = "";
280 auto ret = MetaInfoManager::GetInstance()->SyncDataByNetworkId(networkId);
281 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
282
283 networkId = "networkId_test";
284 ret = MetaInfoManager::GetInstance()->SyncDataByNetworkId(networkId);
285 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
286 }
287
288 HWTEST_F(MetaInfoMgrTest, SyncDataByNetworkId_002, TestSize.Level1)
289 {
290 std::string networkId = "networkId_test";
291 MetaInfoManager::GetInstance()->Init();
292 auto ret = MetaInfoManager::GetInstance()->SyncDataByNetworkId(networkId);
293 EXPECT_EQ(DH_FWK_SUCCESS, ret);
294 MetaInfoManager::GetInstance()->UnInit();
295 }
296
297 HWTEST_F(MetaInfoMgrTest, RemoveMetaInfoInMemByUdid_001, TestSize.Level1)
298 {
299 std::string peerudid = "123456789";
300 std::string peerudIdHash = Sha256(peerudid);
301 std::string deviceId = "deviceId_test";
302 std::string udidHash = "udidHash_test";
303 std::string dhId = "dhId_test";
304 std::shared_ptr<MetaCapabilityInfo> metaCapPtr = std::make_shared<MetaCapabilityInfo>(
305 dhId, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs_test", "subtype", udidHash,
306 CompVersion{ .sinkVersion = "1.0" });
307 std::string key = peerudIdHash + "###" + dhId;
308 MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = metaCapPtr;
309 auto ret = MetaInfoManager::GetInstance()->RemoveMetaInfoInMemByUdid(deviceId);
310 EXPECT_EQ(DH_FWK_SUCCESS, ret);
311
312 ret = MetaInfoManager::GetInstance()->RemoveMetaInfoInMemByUdid(peerudid);
313 EXPECT_EQ(DH_FWK_SUCCESS, ret);
314 }
315
316 HWTEST_F(MetaInfoMgrTest, ClearRemoteDeviceMetaInfoData_001, TestSize.Level1)
317 {
318 MetaInfoManager::GetInstance()->Init();
319 std::string peerudid = "";
320 std::string peeruuid = "";
321 auto ret = MetaInfoManager::GetInstance()->ClearRemoteDeviceMetaInfoData(peerudid, peeruuid);
322 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
323
324 peerudid = "peerudid_test";
325 peeruuid = "peeruuid_test";
326 ret = MetaInfoManager::GetInstance()->ClearRemoteDeviceMetaInfoData(peerudid, peeruuid);
327 EXPECT_EQ(DH_FWK_SUCCESS, ret);
328
329 MetaInfoManager::GetInstance()->UnInit();
330 ret = MetaInfoManager::GetInstance()->ClearRemoteDeviceMetaInfoData(peerudid, peeruuid);
331 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
332 }
333
334 HWTEST_F(MetaInfoMgrTest, OnChange_001, TestSize.Level1)
335 {
336 DistributedKv::Entry insert, update, del;
337 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
338 inserts.push_back(insert);
339 updates.push_back(update);
340 deleteds.push_back(del);
341 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
342 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->OnChange(changeIn));
343 }
344
345 HWTEST_F(MetaInfoMgrTest, OnChange_002, TestSize.Level1)
346 {
347 DistributedKv::Entry insert, update, del;
348 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
349 std::string tempStr;
350 for (int32_t i = 1; i < MAX_DB_RECORD_LENGTH; i++) {
351 tempStr = std::to_string(i);
352 insert.key = tempStr.c_str();
353 update.key = tempStr.c_str();
354 del.key = tempStr.c_str();
355 insert.value = tempStr.c_str();
356 update.value = tempStr.c_str();
357 del.value = tempStr.c_str();
358 inserts.push_back(insert);
359 updates.push_back(update);
360 deleteds.push_back(del);
361 }
362 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
363 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->OnChange(changeIn));
364 }
365
366 HWTEST_F(MetaInfoMgrTest, OnChange_003, TestSize.Level1)
367 {
368 DistributedKv::Entry insert, update, del;
369 insert.key = "insert_key";
370 update.key = "update_key";
371 del.key = "del_key";
372 insert.value = "insert_value";
373 update.value = "update_value";
374 del.value = "del_value";
375 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
376 inserts.push_back(insert);
377 updates.push_back(update);
378 deleteds.push_back(del);
379
380 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
381 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->OnChange(changeIn));
382 }
383
384 HWTEST_F(MetaInfoMgrTest, OnChange_004, TestSize.Level1)
385 {
386 DistributedKv::DataOrigin origin;
387 origin.id = {};
388 origin.store = "";
389 MetaInfoManager::Keys keys;
390 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->OnChange(origin, std::move(keys)));
391 }
392
393 HWTEST_F(MetaInfoMgrTest, OnChange_005, TestSize.Level1)
394 {
395 DistributedKv::DataOrigin origin;
396 origin.id = {};
397 origin.store = "";
398 MetaInfoManager::Keys keys;
399 keys[MetaInfoManager::OP_INSERT] = {"insert"};
400 keys[MetaInfoManager::OP_UPDATE] = {"update"};
401 keys[MetaInfoManager::OP_DELETE] = {"delete"};
402 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->OnChange(origin, std::move(keys)));
403 }
404
405 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityAddChange_001, TestSize.Level1)
406 {
407 cJSON *jsonObj = cJSON_CreateObject();
408 ASSERT_TRUE(jsonObj != nullptr);
409 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
410 cJSON_AddStringToObject(jsonObj, DEV_ID, "222222");
411 char* cjson = cJSON_PrintUnformatted(jsonObj);
412 if (cjson == nullptr) {
413 cJSON_Delete(jsonObj);
414 return;
415 }
416 std::string jsonStr(cjson);
417 std::vector<DistributedKv::Entry> insertRecords;
418 DistributedKv::Entry entry;
419 entry.key = "insert";
420 entry.value = jsonStr.c_str();
421 insertRecords.push_back(entry);
422 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityAddChange(insertRecords));
423 cJSON_free(cjson);
424 cJSON_Delete(jsonObj);
425 }
426
427 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityAddChange_002, TestSize.Level1)
428 {
429 std::string uuid = "123456789";
430 std::string deviceId = Sha256(uuid);
431 DeviceIdEntry idEntry = {
432 .networkId = "",
433 .uuid = uuid,
434 .deviceId = deviceId
435 };
436 DHContext::GetInstance().devIdEntrySet_.insert(idEntry);
437 cJSON *jsonObj = cJSON_CreateObject();
438 ASSERT_TRUE(jsonObj != nullptr);
439 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
440 cJSON_AddStringToObject(jsonObj, DEV_ID, deviceId.c_str());
441 char* cjson = cJSON_PrintUnformatted(jsonObj);
442 if (cjson == nullptr) {
443 cJSON_Delete(jsonObj);
444 return;
445 }
446 std::string jsonStr(cjson);
447 std::vector<DistributedKv::Entry> insertRecords;
448 DistributedKv::Entry entry;
449 entry.key = "insert";
450 entry.value = jsonStr.c_str();
451 insertRecords.push_back(entry);
452 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityAddChange(insertRecords));
453 DHContext::GetInstance().devIdEntrySet_.clear();
454 cJSON_free(cjson);
455 cJSON_Delete(jsonObj);
456 }
457
458 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityAddChange_003, TestSize.Level1)
459 {
460 std::string uuid = "123456789";
461 std::string deviceId = Sha256(uuid);
462 cJSON *jsonObj = cJSON_CreateObject();
463 ASSERT_TRUE(jsonObj != nullptr);
464 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
465 cJSON_AddStringToObject(jsonObj, DEV_ID, deviceId.c_str());
466 char* cjson = cJSON_PrintUnformatted(jsonObj);
467 if (cjson == nullptr) {
468 cJSON_Delete(jsonObj);
469 return;
470 }
471 std::string jsonStr(cjson);
472 DHContext::GetInstance().AddOnlineDevice("111111", uuid, "222222");
473 std::vector<DistributedKv::Entry> insertRecords;
474 DistributedKv::Entry entry;
475 entry.key = "insert";
476 entry.value = jsonStr.c_str();
477 insertRecords.push_back(entry);
478 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityAddChange(insertRecords));
479 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId("222222");
480 cJSON_free(cjson);
481 cJSON_Delete(jsonObj);
482 }
483
484 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityUpdateChange_001, TestSize.Level1)
485 {
486 cJSON *jsonObj = cJSON_CreateObject();
487 ASSERT_TRUE(jsonObj != nullptr);
488 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
489 cJSON_AddStringToObject(jsonObj, DEV_ID, "222222");
490 char* cjson = cJSON_PrintUnformatted(jsonObj);
491 if (cjson == nullptr) {
492 cJSON_Delete(jsonObj);
493 return;
494 }
495 std::string jsonStr(cjson);
496 std::vector<DistributedKv::Entry> updateRecords;
497 DistributedKv::Entry update;
498 update.key = "update";
499 update.value = jsonStr.c_str();
500 updateRecords.push_back(update);
501 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityUpdateChange(updateRecords));
502 cJSON_free(cjson);
503 cJSON_Delete(jsonObj);
504 }
505
506 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityUpdateChange_002, TestSize.Level1)
507 {
508 std::string uuid = "123456789";
509 std::string deviceId = Sha256(uuid);
510 DeviceIdEntry idEntry = {
511 .networkId = "",
512 .uuid = uuid,
513 .deviceId = deviceId
514 };
515 cJSON *jsonObj = cJSON_CreateObject();
516 ASSERT_TRUE(jsonObj != nullptr);
517 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
518 cJSON_AddStringToObject(jsonObj, DEV_ID, deviceId.c_str());
519 char* cjson = cJSON_PrintUnformatted(jsonObj);
520 if (cjson == nullptr) {
521 cJSON_Delete(jsonObj);
522 return;
523 }
524 std::string jsonStr(cjson);
525 std::vector<DistributedKv::Entry> updateRecords;
526 DistributedKv::Entry update;
527 update.key = "update";
528 update.value = jsonStr.c_str();
529 updateRecords.push_back(update);
530 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityUpdateChange(updateRecords));
531 DHContext::GetInstance().devIdEntrySet_.clear();
532 cJSON_free(cjson);
533 cJSON_Delete(jsonObj);
534 }
535
536 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityUpdateChange_003, TestSize.Level1)
537 {
538 std::string uuid = "123456789";
539 std::string deviceId = Sha256(uuid);
540 cJSON *jsonObj = cJSON_CreateObject();
541 ASSERT_TRUE(jsonObj != nullptr);
542 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
543 cJSON_AddStringToObject(jsonObj, DEV_ID, deviceId.c_str());
544 char* cjson = cJSON_PrintUnformatted(jsonObj);
545 if (cjson == nullptr) {
546 cJSON_Delete(jsonObj);
547 return;
548 }
549 std::string jsonStr(cjson);
550 std::vector<DistributedKv::Entry> updateRecords;
551 DHContext::GetInstance().AddOnlineDevice("111111", uuid, "222222");
552 DistributedKv::Entry update;
553 update.key = "update";
554 update.value = jsonStr.c_str();
555 updateRecords.push_back(update);
556 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityUpdateChange(updateRecords));
557
558 std::string enabledDeviceKey = deviceId + RESOURCE_SEPARATOR + "111111";
559 TaskParam taskParam;
560 TaskBoard::GetInstance().SaveEnabledDevice(enabledDeviceKey, taskParam);
561 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityUpdateChange(updateRecords));
562
563 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId("222222");
564 cJSON_free(cjson);
565 cJSON_Delete(jsonObj);
566 }
567
568 HWTEST_F(MetaInfoMgrTest, HandleMetaCapabilityDeleteChange_001, TestSize.Level1)
569 {
570 cJSON *jsonObj = cJSON_CreateObject();
571 ASSERT_TRUE(jsonObj != nullptr);
572 cJSON_AddStringToObject(jsonObj, DH_ID, "111111");
573 cJSON_AddStringToObject(jsonObj, DEV_ID, "222222");
574 char* cjson = cJSON_PrintUnformatted(jsonObj);
575 if (cjson == nullptr) {
576 cJSON_Delete(jsonObj);
577 return;
578 }
579 std::string jsonStr(cjson);
580 std::vector<DistributedKv::Entry> deleteRecords;
581 DistributedKv::Entry del;
582 del.key = "update";
583 del.value = jsonStr.c_str();
584 deleteRecords.push_back(del);
585 ASSERT_NO_FATAL_FAILURE(MetaInfoManager::GetInstance()->HandleMetaCapabilityDeleteChange(deleteRecords));
586 cJSON_free(cjson);
587 cJSON_Delete(jsonObj);
588 }
589
590 HWTEST_F(MetaInfoMgrTest, GetEntriesByKeys_001, TestSize.Level1)
591 {
592 std::vector<std::string> keys;
593 auto ret = MetaInfoManager::GetInstance()->GetEntriesByKeys(keys);
594 EXPECT_EQ(0, ret.size());
595
596 keys.push_back("key_test");
597 ret = MetaInfoManager::GetInstance()->GetEntriesByKeys(keys);
598 EXPECT_EQ(0, ret.size());
599
600 MetaInfoManager::GetInstance()->Init();
601 ret = MetaInfoManager::GetInstance()->GetEntriesByKeys(keys);
602 EXPECT_EQ(0, ret.size());
603 MetaInfoManager::GetInstance()->UnInit();
604 }
605 }
606 }