1 /*
2 * Copyright (c) 2022-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 "version_info_manager_test.h"
17
18 #include <cerrno>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21
22 #include "version_info_manager.h"
23 #include "version_manager.h"
24 #include "dh_context.h"
25 #include "distributed_hardware_log.h"
26 #include "dh_utils_tool.h"
27
28 using namespace testing::ext;
29 using namespace std;
30
31 namespace OHOS {
32 namespace DistributedHardware {
33 #undef DH_LOG_TAG
34 #define DH_LOG_TAG "VersionInfoManagerTest"
35
36 namespace {
37 const string DATABASE_DIR = "/data/service/el1/public/database/dtbhardware_manager_service/";
38 const string DEV_ID_1 = "bb536a637105409e904d4da83790a4a7";
39 const string DEV_ID_2 = "bb536a637105409e904d4da83790a4a8";
40 const string DEV_ID_3 = "bb536a637105409e904d4da83790a4a9";
41 const string NAME_SCREEN = "distributed_screen";
42 const string NAME_CAMERA = "distributed_camera";
43 const string NAME_INPUT = "distributed_input";
44 const string VERSION_1 = "1.0";
45 const string VERSION_2 = "2.0";
46 const string VERSION_3 = "3.0";
47 std::vector<VersionInfo> g_versionInfos;
48 constexpr uint32_t MAX_DB_RECORD_LENGTH = 10005;
49 }
50
CreateVersionInfos()51 std::vector<VersionInfo> CreateVersionInfos()
52 {
53 CompVersion compVersions1 = {
54 .name = NAME_CAMERA,
55 .dhType = DHType::CAMERA,
56 .handlerVersion = VERSION_1,
57 .sourceVersion = VERSION_1,
58 .sinkVersion = VERSION_1
59 };
60
61 CompVersion compVersions2 = {
62 .name = NAME_SCREEN,
63 .dhType = DHType::SCREEN,
64 .handlerVersion = VERSION_2,
65 .sourceVersion = VERSION_2,
66 .sinkVersion = VERSION_2
67 };
68
69 CompVersion compVersions3 = {
70 .name = NAME_INPUT,
71 .dhType = DHType::INPUT,
72 .handlerVersion = VERSION_3,
73 .sourceVersion = VERSION_3,
74 .sinkVersion = VERSION_3
75 };
76
77 VersionInfo verInfo1;
78 verInfo1.deviceId = DEV_ID_1;
79 verInfo1.dhVersion = VERSION_1;
80 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions1.dhType, compVersions1));
81 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions1.dhType, compVersions1));
82 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions1.dhType, compVersions1));
83
84 VersionInfo verInfo2;
85 verInfo2.deviceId = DEV_ID_2;
86 verInfo1.dhVersion = VERSION_2;
87 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions2.dhType, compVersions2));
88 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions2.dhType, compVersions2));
89 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions2.dhType, compVersions2));
90
91 VersionInfo verInfo3;
92 verInfo3.deviceId = DEV_ID_3;
93 verInfo1.dhVersion = VERSION_3;
94 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions3.dhType, compVersions3));
95 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions3.dhType, compVersions3));
96 verInfo1.compVersions.insert(std::pair<DHType, CompVersion>(compVersions3.dhType, compVersions3));
97
98 return std::vector<VersionInfo> { verInfo1, verInfo2, verInfo3 };
99 }
100
SetUpTestCase(void)101 void VersionInfoManagerTest::SetUpTestCase(void)
102 {
103 auto ret = mkdir(DATABASE_DIR.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
104 if (ret != 0) {
105 DHLOGE("mkdir failed, path: %{public}s, errno : %{public}d", DATABASE_DIR.c_str(), errno);
106 }
107
108 g_versionInfos = CreateVersionInfos();
109 }
110
TearDownTestCase(void)111 void VersionInfoManagerTest::TearDownTestCase(void)
112 {
113 auto ret = remove(DATABASE_DIR.c_str());
114 if (ret != 0) {
115 DHLOGE("remove dir failed, path: %{public}s, errno : %{public}d", DATABASE_DIR.c_str(), errno);
116 }
117 }
118
SetUp()119 void VersionInfoManagerTest::SetUp()
120 {
121 }
122
TearDown()123 void VersionInfoManagerTest::TearDown()
124 {
125 }
126
127 /**
128 * @tc.name:version_info_manager_test_001
129 * @tc.desc: Verify the VersionInfoManager Init function.
130 * @tc.type: FUNC
131 * @tc.require: AR000GHSCV
132 */
133 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_001, TestSize.Level1)
134 {
135 EXPECT_EQ(VersionInfoManager::GetInstance()->Init(), DH_FWK_SUCCESS);
136 }
137
138 /**
139 * @tc.name:version_info_manager_test_002
140 * @tc.desc: Verify the VersionInfoManager AddVersion function.
141 * @tc.type: FUNC
142 * @tc.require: AR000GHSCV
143 */
144 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_002, TestSize.Level1)
145 {
146 for (const auto& verInfo : g_versionInfos) {
147 EXPECT_EQ(VersionInfoManager::GetInstance()->AddVersion(verInfo), DH_FWK_SUCCESS);
148 }
149 }
150
151 /**
152 * @tc.name:version_info_manager_test_003
153 * @tc.desc: Verify the VersionInfoManager GetVersionInfoByDeviceId function.
154 * @tc.type: FUNC
155 * @tc.require: AR000GHSJE
156 */
157 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_003, TestSize.Level1)
158 {
159 VersionInfo versionInfo;
160 for (const auto& verInfo : g_versionInfos) {
161 EXPECT_EQ(VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(verInfo.deviceId, versionInfo),
162 DH_FWK_SUCCESS);
163 }
164 }
165
166 /**
167 * @tc.name:version_info_manager_test_004
168 * @tc.desc: Verify the VersionInfoManager SyncVersionInfoFromDB function.
169 * @tc.type: FUNC
170 * @tc.require: AR000GHSJE
171 */
172 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_004, TestSize.Level1)
173 {
174 EXPECT_EQ(VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(DEV_ID_1), DH_FWK_SUCCESS);
175 }
176
177 /**
178 * @tc.name:version_info_manager_test_005
179 * @tc.desc: Verify the VersionInfoManager UnInit function.
180 * @tc.type: FUNC
181 * @tc.require: AR000GHSJE
182 */
183 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_005, TestSize.Level1)
184 {
185 EXPECT_EQ(VersionInfoManager::GetInstance()->UnInit(), DH_FWK_SUCCESS);
186 }
187
188 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_006, TestSize.Level1)
189 {
190 VersionInfoManager::GetInstance()->dbAdapterPtr_= nullptr;
191 auto ret = VersionInfoManager::GetInstance()->UnInit();
192 EXPECT_EQ(ERR_DH_FWK_RESOURCE_UNINIT_DB_FAILED, ret);
193 }
194
195 /**
196 * @tc.name: UpdateVersionCache_001
197 * @tc.desc: Verify the UpdateVersionCache function
198 * @tc.type: FUNC
199 * @tc.require: AR000GHSJM
200 */
201 HWTEST_F(VersionInfoManagerTest, UpdateVersionCache_001, TestSize.Level1)
202 {
203 VersionInfo versionInfo;
204 versionInfo.deviceId = "deviceId";
205 versionInfo.dhVersion = "dhVersion";
206 VersionInfoManager::GetInstance()->UpdateVersionCache(versionInfo);
207 EXPECT_EQ(DH_FWK_SUCCESS, VersionInfoManager::GetInstance()->Init());
208 }
209
210 /**
211 * @tc.name: UpdateVersionCache_002
212 * @tc.desc: Verify the UpdateVersionCache function
213 * @tc.type: FUNC
214 * @tc.require: AR000GHSJM
215 */
216 HWTEST_F(VersionInfoManagerTest, UpdateVersionCache_002, TestSize.Level1)
217 {
218 std::string testUdid = "111111";
219 std::string testUuid = "222222";
220 std::string testNetworkId = "333333";
221 std::string testDeviceId = Sha256(testUuid);
222 VersionInfo versionInfo = {
223 .deviceId = testDeviceId,
224 .dhVersion = "1.0"
225 };
226 DHContext::GetInstance().AddOnlineDevice(testUdid, testUuid, testNetworkId);
227 VersionInfoManager::GetInstance()->UpdateVersionCache(versionInfo);
228 EXPECT_FALSE(versionInfo.dhVersion.empty());
229 }
230
231 /**
232 * @tc.name: RemoveVersionInfoByDeviceId_001
233 * @tc.desc: Verify the RemoveVersionInfoByDeviceId function
234 * @tc.type: FUNC
235 * @tc.require: AR000GHSJM
236 */
237 HWTEST_F(VersionInfoManagerTest, RemoveVersionInfoByDeviceId_001, TestSize.Level1)
238 {
239 std::string deviceId = DEV_ID_1;
240 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
241 int32_t ret = VersionInfoManager::GetInstance()->RemoveVersionInfoByDeviceId(deviceId);
242 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
243
244 deviceId = "";
245 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
246 ret = VersionInfoManager::GetInstance()->RemoveVersionInfoByDeviceId(deviceId);
247 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
248 }
249
250 /**
251 * @tc.name: RemoveVersionInfoByDeviceId_002
252 * @tc.desc: Verify the RemoveVersionInfoByDeviceId function
253 * @tc.type: FUNC
254 * @tc.require: AR000GHSJM
255 */
256 HWTEST_F(VersionInfoManagerTest, RemoveVersionInfoByDeviceId_002, TestSize.Level1)
257 {
258 std::string deviceId = "deviceId";
259 std::string appId;
260 std::string storeId;
261 std::shared_ptr<DistributedKv::KvStoreObserver> changeListener = nullptr;
262 VersionInfoManager::GetInstance()->dbAdapterPtr_ =
263 std::make_shared<MockDBAdapter>(appId.c_str(), storeId.c_str(), changeListener);
264 int32_t ret = VersionInfoManager::GetInstance()->RemoveVersionInfoByDeviceId(deviceId);
265 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
266 }
267
268 /**
269 * @tc.name: SyncVersionInfoFromDB_001
270 * @tc.desc: Verify the SyncVersionInfoFromDB function
271 * @tc.type: FUNC
272 * @tc.require: AR000GHSJM
273 */
274 HWTEST_F(VersionInfoManagerTest, SyncVersionInfoFromDB_001, TestSize.Level1)
275 {
276 std::string deviceId = DEV_ID_1;
277 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
278 int32_t ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
279 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
280
281 deviceId = "";
282 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
283 ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
284 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
285 }
286
287 /**
288 * @tc.name: SyncVersionInfoFromDB_002
289 * @tc.desc: Verify the SyncVersionInfoFromDB function
290 * @tc.type: FUNC
291 * @tc.require: AR000GHSJM
292 */
293 HWTEST_F(VersionInfoManagerTest, SyncVersionInfoFromDB_002, TestSize.Level1)
294 {
295 std::string deviceId = "deviceId";
296 std::string appId;
297 std::string storeId;
298 std::shared_ptr<DistributedKv::KvStoreObserver> changeListener = nullptr;
299 VersionInfoManager::GetInstance()->dbAdapterPtr_ =
300 std::make_shared<MockDBAdapter>(appId.c_str(), storeId.c_str(), changeListener);
301 int32_t ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
302 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
303 }
304
305 /**
306 * @tc.name: SyncVersionInfoFromDB_003
307 * @tc.desc: Verify the SyncVersionInfoFromDB function
308 * @tc.type: FUNC
309 * @tc.require: AR000GHSJM
310 */
311 HWTEST_F(VersionInfoManagerTest, SyncVersionInfoFromDB_003, TestSize.Level1)
312 {
313 std::string deviceId = "device";
314 int32_t ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
315 EXPECT_NE(DH_FWK_SUCCESS, ret);
316 }
317
318 /**
319 * @tc.name: SyncRemoteVersionInfos_001
320 * @tc.desc: Verify the SyncRemoteVersionInfos function
321 * @tc.type: FUNC
322 * @tc.require: AR000GHSJM
323 */
324 HWTEST_F(VersionInfoManagerTest, SyncRemoteVersionInfos_001, TestSize.Level1)
325 {
326 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
327 int32_t ret = VersionInfoManager::GetInstance()->SyncRemoteVersionInfos();
328 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
329 }
330
331 /**
332 * @tc.name: SyncRemoteVersionInfos_002
333 * @tc.desc: Verify the SyncRemoteVersionInfos function
334 * @tc.type: FUNC
335 * @tc.require: AR000GHSJM
336 */
337 HWTEST_F(VersionInfoManagerTest, SyncRemoteVersionInfos_002, TestSize.Level1)
338 {
339 std::string udid = "udid_123456";
340 std::string uuid = "uuid_123456";
341 std::string networkId = "networkId_123456";
342 DHContext::GetInstance().AddOnlineDevice(udid, uuid, networkId);
343 std::string appId;
344 std::string storeId;
345 std::shared_ptr<DistributedKv::KvStoreObserver> changeListener = nullptr;
346 VersionInfoManager::GetInstance()->dbAdapterPtr_ =
347 std::make_shared<MockDBAdapter>(appId.c_str(), storeId.c_str(), changeListener);
348 int32_t ret = VersionInfoManager::GetInstance()->SyncRemoteVersionInfos();
349 EXPECT_EQ(DH_FWK_SUCCESS, ret);
350 }
351
352 /**
353 * @tc.name: OnChange_001
354 * @tc.desc: Verify the OnChange function
355 * @tc.type: FUNC
356 * @tc.require: AR000GHSJM
357 */
358 HWTEST_F(VersionInfoManagerTest, OnChange_001, TestSize.Level1)
359 {
360 DistributedKv::Entry insert, update, del;
361 insert.key = "strBase";
362 update.key = "strBase";
363 del.key = "strBase";
364 insert.value = "strBase";
365 update.value = "strBase";
366 del.value = "strBase";
367 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
368 inserts.push_back(insert);
369 updates.push_back(update);
370 deleteds.push_back(del);
371 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
372 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->OnChange(changeIn));
373 }
374
375 HWTEST_F(VersionInfoManagerTest, OnChange_002, TestSize.Level1)
376 {
377 DistributedKv::Entry insert, update, del;
378 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
379 std::string tempStr;
380 for (int32_t i = 1; i < MAX_DB_RECORD_LENGTH; i++) {
381 tempStr = std::to_string(i);
382 insert.key = tempStr.c_str();
383 update.key = tempStr.c_str();
384 del.key = tempStr.c_str();
385 insert.value = tempStr.c_str();
386 update.value = tempStr.c_str();
387 del.value = tempStr.c_str();
388 inserts.push_back(insert);
389 updates.push_back(update);
390 deleteds.push_back(del);
391 }
392 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
393 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->OnChange(changeIn));
394 }
395
396 HWTEST_F(VersionInfoManagerTest, OnChange_003, TestSize.Level1)
397 {
398 DistributedKv::Entry insert, update, del;
399 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
400 inserts.push_back(insert);
401 updates.push_back(update);
402 deleteds.push_back(del);
403 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
404 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->OnChange(changeIn));
405 }
406
407 /**
408 * @tc.name: HandleVersionChange_001
409 * @tc.desc: Verify the HandleVersionAddChange HandleVersionUpdateChange HandleVersionDeleteChange function
410 * @tc.type: FUNC
411 * @tc.require: AR000GHSJM
412 */
413 HWTEST_F(VersionInfoManagerTest, HandleVersionChange_001, TestSize.Level1)
414 {
415 cJSON *jsonObj = cJSON_CreateObject();
416 ASSERT_TRUE(jsonObj != nullptr);
417 cJSON_AddStringToObject(jsonObj, DEV_ID, "222222");
418 cJSON_AddStringToObject(jsonObj, DH_VER, "1.0");
419 char* cjson = cJSON_PrintUnformatted(jsonObj);
420 if (cjson == nullptr) {
421 cJSON_Delete(jsonObj);
422 return;
423 }
424 std::string jsonStr(cjson);
425
426 std::vector<DistributedKv::Entry> insertRecords;
427 DistributedKv::Entry entry;
428 entry.key = "insert";
429 entry.value = jsonStr.c_str();
430 insertRecords.push_back(entry);
431 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionAddChange(insertRecords));
432
433 std::vector<DistributedKv::Entry> updateRecords;
434 DistributedKv::Entry update;
435 update.key = "update";
436 update.value = jsonStr.c_str();
437 updateRecords.push_back(update);
438 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionUpdateChange(updateRecords));
439
440 std::vector<DistributedKv::Entry> deleteRecords;
441 DistributedKv::Entry del;
442 del.key = "delete";
443 del.value = jsonStr.c_str();
444 deleteRecords.push_back(del);
445 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionDeleteChange(deleteRecords));
446 }
447
448 /**
449 * @tc.name: HandleVersionChange_002
450 * @tc.desc: Verify the HandleVersionDeleteChange function
451 * @tc.type: FUNC
452 * @tc.require: AR000GHSJM
453 */
454 HWTEST_F(VersionInfoManagerTest, HandleVersionChange_002, TestSize.Level1)
455 {
456 std::string uuid = "123456789";
457 DHContext::GetInstance().AddOnlineDevice("111111", uuid, "222222");
458 cJSON *jsonObj = cJSON_CreateObject();
459 ASSERT_TRUE(jsonObj != nullptr);
460 cJSON_AddStringToObject(jsonObj, DEV_ID, "222222");
461 cJSON_AddStringToObject(jsonObj, DH_VER, "1.0");
462 char* cjson = cJSON_PrintUnformatted(jsonObj);
463 if (cjson == nullptr) {
464 cJSON_Delete(jsonObj);
465 return;
466 }
467 std::string jsonStr(cjson);
468 std::vector<DistributedKv::Entry> deleteRecords;
469 DistributedKv::Entry del;
470 del.key = "delete";
471 del.value = jsonStr.c_str();
472 deleteRecords.push_back(del);
473 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionDeleteChange(deleteRecords));
474 }
475
476 /**
477 * @tc.name: GetVersionInfoByDeviceId_001
478 * @tc.desc: Verify the VersionInfoManager GetVersionInfoByDeviceId function.
479 * @tc.type: FUNC
480 * @tc.require: AR000GHSJE
481 */
482 HWTEST_F(VersionInfoManagerTest, GetVersionInfoByDeviceId_001, TestSize.Level1)
483 {
484 std::string deviceId = DEV_ID_1;
485 VersionInfo versionInfo;
486 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
487 int32_t ret = VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(deviceId, versionInfo);
488 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
489
490 deviceId = "";
491 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
492 ret = VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(deviceId, versionInfo);
493 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
494 }
495
496 HWTEST_F(VersionInfoManagerTest, GetVersionInfoByDeviceId_002, TestSize.Level1)
497 {
498 std::string deviceId = DEV_ID_1;
499 VersionInfo versionInfo;
500 VersionInfoManager::GetInstance()->Init();
501 int32_t ret = VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(deviceId, versionInfo);
502 EXPECT_EQ(DH_FWK_SUCCESS, ret);
503 }
504 } // namespace DistributedHardware
505 } // namespace OHOS
506