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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
184 {
185 EXPECT_EQ(VersionInfoManager::GetInstance()->UnInit(), DH_FWK_SUCCESS);
186 }
187
188 HWTEST_F(VersionInfoManagerTest, version_info_manager_test_006, TestSize.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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_ = std::make_shared<MockDBAdapter>(appId, storeId, changeListener);
263 int32_t ret = VersionInfoManager::GetInstance()->RemoveVersionInfoByDeviceId(deviceId);
264 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
265 }
266
267 /**
268 * @tc.name: SyncVersionInfoFromDB_001
269 * @tc.desc: Verify the SyncVersionInfoFromDB function
270 * @tc.type: FUNC
271 * @tc.require: AR000GHSJM
272 */
273 HWTEST_F(VersionInfoManagerTest, SyncVersionInfoFromDB_001, TestSize.Level0)
274 {
275 std::string deviceId = DEV_ID_1;
276 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
277 int32_t ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
278 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
279
280 deviceId = "";
281 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
282 ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
283 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
284 }
285
286 /**
287 * @tc.name: SyncVersionInfoFromDB_002
288 * @tc.desc: Verify the SyncVersionInfoFromDB function
289 * @tc.type: FUNC
290 * @tc.require: AR000GHSJM
291 */
292 HWTEST_F(VersionInfoManagerTest, SyncVersionInfoFromDB_002, TestSize.Level0)
293 {
294 std::string deviceId = "deviceId";
295 std::string appId;
296 std::string storeId;
297 std::shared_ptr<DistributedKv::KvStoreObserver> changeListener = nullptr;
298 VersionInfoManager::GetInstance()->dbAdapterPtr_ = std::make_shared<MockDBAdapter>(appId, storeId, changeListener);
299 int32_t ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
300 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
301 }
302
303 /**
304 * @tc.name: SyncVersionInfoFromDB_003
305 * @tc.desc: Verify the SyncVersionInfoFromDB function
306 * @tc.type: FUNC
307 * @tc.require: AR000GHSJM
308 */
309 HWTEST_F(VersionInfoManagerTest, SyncVersionInfoFromDB_003, TestSize.Level0)
310 {
311 std::string deviceId = "device";
312 int32_t ret = VersionInfoManager::GetInstance()->SyncVersionInfoFromDB(deviceId);
313 EXPECT_NE(DH_FWK_SUCCESS, ret);
314 }
315
316 /**
317 * @tc.name: SyncRemoteVersionInfos_001
318 * @tc.desc: Verify the SyncRemoteVersionInfos function
319 * @tc.type: FUNC
320 * @tc.require: AR000GHSJM
321 */
322 HWTEST_F(VersionInfoManagerTest, SyncRemoteVersionInfos_001, TestSize.Level0)
323 {
324 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
325 int32_t ret = VersionInfoManager::GetInstance()->SyncRemoteVersionInfos();
326 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
327 }
328
329 /**
330 * @tc.name: SyncRemoteVersionInfos_002
331 * @tc.desc: Verify the SyncRemoteVersionInfos function
332 * @tc.type: FUNC
333 * @tc.require: AR000GHSJM
334 */
335 HWTEST_F(VersionInfoManagerTest, SyncRemoteVersionInfos_002, TestSize.Level0)
336 {
337 std::string udid = "udid_123456";
338 std::string uuid = "uuid_123456";
339 std::string networkId = "networkId_123456";
340 DHContext::GetInstance().AddOnlineDevice(udid, uuid, networkId);
341 std::string appId;
342 std::string storeId;
343 std::shared_ptr<DistributedKv::KvStoreObserver> changeListener = nullptr;
344 VersionInfoManager::GetInstance()->dbAdapterPtr_ = std::make_shared<MockDBAdapter>(appId, storeId, changeListener);
345 int32_t ret = VersionInfoManager::GetInstance()->SyncRemoteVersionInfos();
346 EXPECT_EQ(DH_FWK_SUCCESS, ret);
347 }
348
349 /**
350 * @tc.name: OnChange_001
351 * @tc.desc: Verify the OnChange function
352 * @tc.type: FUNC
353 * @tc.require: AR000GHSJM
354 */
355 HWTEST_F(VersionInfoManagerTest, OnChange_001, TestSize.Level0)
356 {
357 DistributedKv::Entry insert, update, del;
358 insert.key = "strBase";
359 update.key = "strBase";
360 del.key = "strBase";
361 insert.value = "strBase";
362 update.value = "strBase";
363 del.value = "strBase";
364 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
365 inserts.push_back(insert);
366 updates.push_back(update);
367 deleteds.push_back(del);
368 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
369 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->OnChange(changeIn));
370 }
371
372 HWTEST_F(VersionInfoManagerTest, OnChange_002, TestSize.Level0)
373 {
374 DistributedKv::Entry insert, update, del;
375 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
376 std::string tempStr;
377 for (int32_t i = 1; i < MAX_DB_RECORD_LENGTH; i++) {
378 tempStr = std::to_string(i);
379 insert.key = tempStr.c_str();
380 update.key = tempStr.c_str();
381 del.key = tempStr.c_str();
382 insert.value = tempStr.c_str();
383 update.value = tempStr.c_str();
384 del.value = tempStr.c_str();
385 inserts.push_back(insert);
386 updates.push_back(update);
387 deleteds.push_back(del);
388 }
389 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
390 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->OnChange(changeIn));
391 }
392
393 HWTEST_F(VersionInfoManagerTest, OnChange_003, TestSize.Level0)
394 {
395 DistributedKv::Entry insert, update, del;
396 std::vector<DistributedKv::Entry> inserts, updates, deleteds;
397 inserts.push_back(insert);
398 updates.push_back(update);
399 deleteds.push_back(del);
400 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
401 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->OnChange(changeIn));
402 }
403
404 /**
405 * @tc.name: HandleVersionChange_001
406 * @tc.desc: Verify the HandleVersionAddChange HandleVersionUpdateChange HandleVersionDeleteChange function
407 * @tc.type: FUNC
408 * @tc.require: AR000GHSJM
409 */
410 HWTEST_F(VersionInfoManagerTest, HandleVersionChange_001, TestSize.Level0)
411 {
412 cJSON *jsonObj = cJSON_CreateObject();
413 ASSERT_TRUE(jsonObj != nullptr);
414 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "222222");
415 cJSON_AddStringToObject(jsonObj, DH_VER.c_str(), "1.0");
416 char* cjson = cJSON_PrintUnformatted(jsonObj);
417 if (cjson == nullptr) {
418 cJSON_Delete(jsonObj);
419 return;
420 }
421 std::string jsonStr(cjson);
422
423 std::vector<DistributedKv::Entry> insertRecords;
424 DistributedKv::Entry entry;
425 entry.key = "insert";
426 entry.value = jsonStr.c_str();
427 insertRecords.push_back(entry);
428 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionAddChange(insertRecords));
429
430 std::vector<DistributedKv::Entry> updateRecords;
431 DistributedKv::Entry update;
432 update.key = "update";
433 update.value = jsonStr.c_str();
434 updateRecords.push_back(update);
435 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionUpdateChange(updateRecords));
436
437 std::vector<DistributedKv::Entry> deleteRecords;
438 DistributedKv::Entry del;
439 del.key = "delete";
440 del.value = jsonStr.c_str();
441 deleteRecords.push_back(del);
442 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionDeleteChange(deleteRecords));
443 }
444
445 /**
446 * @tc.name: HandleVersionChange_002
447 * @tc.desc: Verify the HandleVersionDeleteChange function
448 * @tc.type: FUNC
449 * @tc.require: AR000GHSJM
450 */
451 HWTEST_F(VersionInfoManagerTest, HandleVersionChange_002, TestSize.Level0)
452 {
453 std::string uuid = "123456789";
454 DHContext::GetInstance().AddOnlineDevice("111111", uuid, "222222");
455 cJSON *jsonObj = cJSON_CreateObject();
456 ASSERT_TRUE(jsonObj != nullptr);
457 cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), "222222");
458 cJSON_AddStringToObject(jsonObj, DH_VER.c_str(), "1.0");
459 char* cjson = cJSON_PrintUnformatted(jsonObj);
460 if (cjson == nullptr) {
461 cJSON_Delete(jsonObj);
462 return;
463 }
464 std::string jsonStr(cjson);
465 std::vector<DistributedKv::Entry> deleteRecords;
466 DistributedKv::Entry del;
467 del.key = "delete";
468 del.value = jsonStr.c_str();
469 deleteRecords.push_back(del);
470 ASSERT_NO_FATAL_FAILURE(VersionInfoManager::GetInstance()->HandleVersionDeleteChange(deleteRecords));
471 }
472
473 /**
474 * @tc.name: GetVersionInfoByDeviceId_001
475 * @tc.desc: Verify the VersionInfoManager GetVersionInfoByDeviceId function.
476 * @tc.type: FUNC
477 * @tc.require: AR000GHSJE
478 */
479 HWTEST_F(VersionInfoManagerTest, GetVersionInfoByDeviceId_001, TestSize.Level0)
480 {
481 std::string deviceId = DEV_ID_1;
482 VersionInfo versionInfo;
483 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
484 int32_t ret = VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(deviceId, versionInfo);
485 EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
486
487 deviceId = "";
488 VersionInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
489 ret = VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(deviceId, versionInfo);
490 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
491 }
492
493 HWTEST_F(VersionInfoManagerTest, GetVersionInfoByDeviceId_002, TestSize.Level0)
494 {
495 std::string deviceId = DEV_ID_1;
496 VersionInfo versionInfo;
497 VersionInfoManager::GetInstance()->Init();
498 int32_t ret = VersionInfoManager::GetInstance()->GetVersionInfoByDeviceId(deviceId, versionInfo);
499 EXPECT_EQ(DH_FWK_SUCCESS, ret);
500 }
501 } // namespace DistributedHardware
502 } // namespace OHOS
503