1 /*
2  * Copyright (c) 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 #define LOG_TAG "ObjectManagerTest"
17 
18 #include "object_manager.h"
19 #include <gtest/gtest.h>
20 #include "snapshot/machine_status.h"
21 #include "executor_pool.h"
22 #include "object_types.h"
23 #include "kv_store_nb_delegate_mock.h"
24 #include <ipc_skeleton.h>
25 
26 using namespace testing::ext;
27 using namespace OHOS::DistributedObject;
28 using AssetValue = OHOS::CommonType::AssetValue;
29 using RestoreStatus = OHOS::DistributedObject::ObjectStoreManager::RestoreStatus;
30 namespace OHOS::Test {
31 
32 class ObjectManagerTest : public testing::Test {
33 public:
34     void SetUp();
35     void TearDown();
36 
37 protected:
38     Asset asset_;
39     std::string uri_;
40     std::string appId_ = "objectManagerTest_appid_1";
41     std::string sessionId_ = "123";
42     std::vector<uint8_t> data_;
43     std::string deviceId_ = "7001005458323933328a258f413b3900";
44     uint64_t sequenceId_ = 10;
45     uint64_t sequenceId_2 = 20;
46     uint64_t sequenceId_3 = 30;
47     std::string userId_ = "100";
48     std::string bundleName_ = "com.examples.hmos.notepad";
49     OHOS::ObjectStore::AssetBindInfo assetBindInfo_;
50     pid_t pid_ = 10;
51     uint32_t tokenId_ = 100;
52     AssetValue assetValue_;
53 };
54 
SetUp()55 void ObjectManagerTest::SetUp()
56 {
57     uri_ = "file:://com.examples.hmos.notepad/data/storage/el2/distributedfiles/dir/asset1.jpg";
58     Asset asset{
59         .name = "test_name",
60         .uri = uri_,
61         .modifyTime = "modifyTime",
62         .size = "size",
63         .hash = "modifyTime_size",
64     };
65     asset_ = asset;
66 
67     AssetValue assetValue{
68         .id = "test_name",
69         .name = uri_,
70         .uri = uri_,
71         .createTime = "2024.07.23",
72         .modifyTime = "modifyTime",
73         .size = "size",
74         .hash = "modifyTime_size",
75         .path = "/data/storage/el2",
76     };
77     assetValue_ = assetValue;
78 
79     data_.push_back(10); // 10 is for testing
80     data_.push_back(20); // 20 is for testing
81     data_.push_back(30); // 30 is for testing
82 
83     OHOS::ObjectStore::AssetBindInfo AssetBindInfo{
84         .storeName = "store_test",
85         .tableName = "table_test",
86         .field = "attachment",
87         .assetName = "asset1.jpg",
88     };
89     assetBindInfo_ = AssetBindInfo;
90 }
91 
TearDown()92 void ObjectManagerTest::TearDown() {}
93 
94 /**
95 * @tc.name: DeleteNotifier001
96 * @tc.desc: DeleteNotifier test.
97 * @tc.type: FUNC
98 * @tc.require:
99 * @tc.author: wangbin
100 */
101 HWTEST_F(ObjectManagerTest, DeleteNotifier001, TestSize.Level0)
102 {
103     auto syncManager = SequenceSyncManager::GetInstance();
104     auto result = syncManager->DeleteNotifier(sequenceId_, userId_);
105     ASSERT_EQ(result, SequenceSyncManager::ERR_SID_NOT_EXIST);
106 }
107 
108 /**
109 * @tc.name: Process001
110 * @tc.desc: Process test.
111 * @tc.type: FUNC
112 * @tc.require:
113 * @tc.author: wangbin
114 */
115 HWTEST_F(ObjectManagerTest, Process001, TestSize.Level0)
116 {
117     auto syncManager = SequenceSyncManager::GetInstance();
118     std::map<std::string, DistributedDB::DBStatus> results;
119     results = {{ "test_cloud", DistributedDB::DBStatus::OK }};
120 
121     std::function<void(const std::map<std::string, int32_t> &results)> func;
__anon1296a7d80102(const std::map<std::string, int32_t> &results) 122     func = [](const std::map<std::string, int32_t> &results) {
123         return results;
124     };
125     auto result = syncManager->Process(sequenceId_, results, userId_);
126     ASSERT_EQ(result, SequenceSyncManager::ERR_SID_NOT_EXIST);
127     syncManager->seqIdCallbackRelations_.emplace(sequenceId_, func);
128     result = syncManager->Process(sequenceId_, results, userId_);
129     ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_HAS_FINISHED);
130 }
131 
132 /**
133 * @tc.name: DeleteNotifierNoLock001
134 * @tc.desc: DeleteNotifierNoLock test.
135 * @tc.type: FUNC
136 * @tc.require:
137 * @tc.author: wangbin
138 */
139 HWTEST_F(ObjectManagerTest, DeleteNotifierNoLock001, TestSize.Level0)
140 {
141     auto syncManager = SequenceSyncManager::GetInstance();
142     std::function<void(const std::map<std::string, int32_t> &results)> func;
__anon1296a7d80202(const std::map<std::string, int32_t> &results) 143     func = [](const std::map<std::string, int32_t> &results) {
144         return results;
145     };
146     syncManager->seqIdCallbackRelations_.emplace(sequenceId_, func);
147     std::vector<uint64_t> seqIds = {sequenceId_, sequenceId_2, sequenceId_3};
148     std::string userId = "user_1";
149     auto result = syncManager->DeleteNotifierNoLock(sequenceId_, userId_);
150     ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_HAS_FINISHED);
151     syncManager->userIdSeqIdRelations_[userId] = seqIds;
152     result = syncManager->DeleteNotifierNoLock(sequenceId_, userId_);
153     ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_IN_USE);
154 }
155 
156 /**
157 * @tc.name: Clear001
158 * @tc.desc: Clear test.
159 * @tc.type: FUNC
160 * @tc.require:
161 * @tc.author: wangbin
162 */
163 HWTEST_F(ObjectManagerTest, Clear001, TestSize.Level0)
164 {
165     auto manager = ObjectStoreManager::GetInstance();
166     auto result = manager->Clear();
167     ASSERT_EQ(result, OHOS::DistributedObject::OBJECT_STORE_NOT_FOUND);
168 }
169 
170 /**
171 * @tc.name: registerAndUnregisterRemoteCallback001
172 * @tc.desc: test RegisterRemoteCallback and UnregisterRemoteCallback.
173 * @tc.type: FUNC
174 * @tc.require:
175 * @tc.author: wangbin
176 */
177 HWTEST_F(ObjectManagerTest, registerAndUnregisterRemoteCallback001, TestSize.Level0)
178 {
179     auto manager = ObjectStoreManager::GetInstance();
180     sptr<IRemoteObject> callback;
181     manager->RegisterRemoteCallback(bundleName_, sessionId_, pid_, tokenId_, callback);
182     ObjectStoreManager::CallbackInfo callbackInfo = manager->callbacks_.Find(tokenId_).second;
183     std::string prefix = bundleName_ + sessionId_;
184     ASSERT_NE(callbackInfo.observers_.find(prefix), callbackInfo.observers_.end());
185     manager->UnregisterRemoteCallback(bundleName_, pid_, tokenId_, sessionId_);
186     callbackInfo = manager->callbacks_.Find(tokenId_).second;
187     ASSERT_EQ(callbackInfo.observers_.find(prefix), callbackInfo.observers_.end());
188 }
189 
190 /**
191 * @tc.name: registerAndUnregisterRemoteCallback002
192 * @tc.desc: abnormal use cases.
193 * @tc.type: FUNC
194 * @tc.require:
195 * @tc.author: wangbin
196 */
197 HWTEST_F(ObjectManagerTest, registerAndUnregisterRemoteCallback002, TestSize.Level0)
198 {
199     auto manager = ObjectStoreManager::GetInstance();
200     sptr<IRemoteObject> callback;
201     uint32_t tokenId = 101;
202     manager->RegisterRemoteCallback("", sessionId_, pid_, tokenId, callback);
203     manager->RegisterRemoteCallback(bundleName_, "", pid_, tokenId, callback);
204     manager->RegisterRemoteCallback("", "", pid_, tokenId, callback);
205     ASSERT_EQ(manager->callbacks_.Find(tokenId).first, false);
206     manager->UnregisterRemoteCallback("", pid_, tokenId, sessionId_);
207 }
208 
209 /**
210 * @tc.name: NotifyDataChanged001
211 * @tc.desc: NotifyDataChanged test.
212 * @tc.type: FUNC
213 * @tc.require:
214 * @tc.author: wangbin
215 */
216 HWTEST_F(ObjectManagerTest, NotifyDataChanged001, TestSize.Level0)
217 {
218     auto manager = ObjectStoreManager::GetInstance();
219     std::string bundleName1_ = "com.examples.ophm.notepad";
220     std::string objectKey = bundleName1_ + sessionId_;
221     std::map<std::string, std::map<std::string, std::vector<uint8_t>>> data;
222     std::map<std::string, std::vector<uint8_t>> data1;
223     std::vector<uint8_t> data1_;
224     data1_.push_back(RestoreStatus::DATA_READY);
225     data1_.push_back(RestoreStatus::ASSETS_READY);
226     data1_.push_back(RestoreStatus::ALL_READY);
227     data1 = {{ "objectKey", data1_ }};
228     data = {{ objectKey, data1 }};
229     std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(5, 3); // executor pool
230     manager->SetThreadPool(executors);
231     ASSERT_EQ(manager->restoreStatus_.Find(objectKey).first, false);
232     manager->NotifyDataChanged(data, {});
233     ASSERT_EQ(manager->restoreStatus_.Find(objectKey).second, RestoreStatus::DATA_READY);
234 }
235 
236 /**
237 * @tc.name: NotifyAssetsReady001
238 * @tc.desc: NotifyAssetsReady test.
239 * @tc.type: FUNC
240 * @tc.require:
241 * @tc.author: wangbin
242 */
243 HWTEST_F(ObjectManagerTest, NotifyAssetsReady001, TestSize.Level0)
244 {
245     auto manager = ObjectStoreManager::GetInstance();
246     std::string objectKey = bundleName_ + sessionId_;
247     std::string srcNetworkId = "1";
248     ASSERT_EQ(manager->restoreStatus_.Find(objectKey).first, false);
249     manager->NotifyAssetsReady(objectKey, srcNetworkId);
250     ASSERT_EQ(manager->restoreStatus_.Find(objectKey).second, RestoreStatus::ASSETS_READY);
251     manager->restoreStatus_.Clear();
252     manager->restoreStatus_.Insert(objectKey, RestoreStatus::DATA_READY);
253     manager->NotifyAssetsReady(objectKey, srcNetworkId);
254     ASSERT_EQ(manager->restoreStatus_.Find(objectKey).second, RestoreStatus::ALL_READY);
255 }
256 
257 /**
258  * @tc.name: NotifyAssetsReady002
259  * @tc.desc: NotifyAssetsReady test.
260  * @tc.type: FUNC
261  */
262 HWTEST_F(ObjectManagerTest, NotifyAssetsReady002, TestSize.Level0)
263 {
264     auto manager = ObjectStoreManager::GetInstance();
265     std::string objectKey="com.example.myapplicaiton123456";
266     std::string srcNetworkId = "654321";
267 
268     manager->restoreStatus_.Clear();
269     manager->NotifyAssetsStart(objectKey, srcNetworkId);
270     auto [has0, value0] = manager->restoreStatus_.Find(objectKey);
271     EXPECT_TRUE(has0);
272     EXPECT_EQ(value0, RestoreStatus::NONE);
273 
274     manager->restoreStatus_.Clear();
275     manager->NotifyAssetsReady(objectKey, srcNetworkId);
276     auto [has1, value1] = manager->restoreStatus_.Find(objectKey);
277     EXPECT_TRUE(has1);
278     EXPECT_EQ(value1, RestoreStatus::ASSETS_READY);
279 
280     manager->restoreStatus_.Clear();
281     manager->restoreStatus_.Insert(objectKey, RestoreStatus::DATA_NOTIFIED);
282     manager->NotifyAssetsReady(objectKey, srcNetworkId);
283     auto [has2, value2] = manager->restoreStatus_.Find(objectKey);
284     EXPECT_TRUE(has2);
285     EXPECT_EQ(value2, RestoreStatus::ALL_READY);
286 
287     manager->restoreStatus_.Clear();
288     manager->restoreStatus_.Insert(objectKey, RestoreStatus::DATA_READY);
289     manager->NotifyAssetsReady(objectKey, srcNetworkId);
290     auto [has3, value3] = manager->restoreStatus_.Find(objectKey);
291     EXPECT_TRUE(has3);
292     EXPECT_EQ(value3, RestoreStatus::ALL_READY);
293     manager->restoreStatus_.Clear();
294 }
295 
296 /**
297 * @tc.name: NotifyChange001
298 * @tc.desc: NotifyChange test.
299 * @tc.type: FUNC
300 * @tc.require:
301 * @tc.author: wangbin
302 */
303 HWTEST_F(ObjectManagerTest, NotifyChange001, TestSize.Level0)
304 {
305     auto manager = ObjectStoreManager::GetInstance();
306     std::map<std::string, std::vector<uint8_t>> data;
307     std::map<std::string, std::vector<uint8_t>> data1;
308     std::vector<uint8_t> data1_;
309     data1_.push_back(RestoreStatus::DATA_READY);
310     data_.push_back(RestoreStatus::ALL_READY);
311     data = {{ "test_cloud", data_ }};
312     data1 = {{ "p_###SAVEINFO###001", data1_ }};
313     manager->NotifyChange(data1);
314     manager->NotifyChange(data);
315 }
316 
317 /**
318  * @tc.name: NotifyChange002
319  * @tc.desc: NotifyChange test.
320  * @tc.type: FUNC
321  */
322 HWTEST_F(ObjectManagerTest, NotifyChange002, TestSize.Level0)
323 {
324     auto manager = ObjectStoreManager::GetInstance();
325     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(1, 0);
326     manager->SetThreadPool(executor);
327     std::map<std::string, std::vector<uint8_t>> data{};
328     std::vector<uint8_t> value{0};
329     std::string bundleName = "com.example.myapplication";
330     std::string sessionId = "123456";
331     std::string source = "source";
332     std::string target = "target";
333     std::string timestamp = "1234567890";
334     ObjectStoreManager::SaveInfo saveInfo(bundleName, sessionId, source, target, timestamp);
335     std::string saveInfoStr = DistributedData::Serializable::Marshall(saveInfo);
336     auto saveInfoValue = std::vector<uint8_t>(saveInfoStr.begin(), saveInfoStr.end());
337     std::string prefix = saveInfo.ToPropertyPrefix();
338     std::string assetPrefix = prefix + "p_asset";
339     data.insert_or_assign(prefix + "p_###SAVEINFO###", saveInfoValue);
340     data.insert_or_assign(prefix + "p_data", value);
341     data.insert_or_assign(assetPrefix + ObjectStore::NAME_SUFFIX, value);
342     data.insert_or_assign(assetPrefix + ObjectStore::URI_SUFFIX, value);
343     data.insert_or_assign(assetPrefix + ObjectStore::PATH_SUFFIX, value);
344     data.insert_or_assign(assetPrefix + ObjectStore::CREATE_TIME_SUFFIX, value);
345     data.insert_or_assign(assetPrefix + ObjectStore::MODIFY_TIME_SUFFIX, value);
346     data.insert_or_assign(assetPrefix + ObjectStore::SIZE_SUFFIX, value);
347     data.insert_or_assign("testkey", value);
348     manager->NotifyChange(data);
349     EXPECT_TRUE(manager->restoreStatus_.Contains(bundleName+sessionId));
350     auto [has, taskId] = manager->objectTimer_.Find(bundleName+sessionId);
351     EXPECT_TRUE(has);
352     manager->restoreStatus_.Clear();
353     manager->executors_->Remove(taskId);
354     manager->objectTimer_.Clear();
355 }
356 
357 /**
358  * @tc.name: ComputeStatus001
359  * @tc.desc: ComputeStatus.test
360  * @tc.type: FUNC
361  */
362 HWTEST_F(ObjectManagerTest, ComputeStatus001, TestSize.Level0)
363 {
364     auto manager = ObjectStoreManager::GetInstance();
365     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(1, 0);
366     manager->SetThreadPool(executor);
367     std::string objectKey="com.example.myapplicaiton123456";
368     std::map<std::string, std::map<std::string, std::vector<uint8_t>>> data{};
369     manager->restoreStatus_.Clear();
370     manager->ComputeStatus(objectKey, {}, data);
371     auto [has0, value0] = manager->restoreStatus_.Find(objectKey);
372     EXPECT_TRUE(has0);
373     EXPECT_EQ(value0, RestoreStatus::DATA_READY);
374     auto [has1, taskId1] = manager->objectTimer_.Find(objectKey);
375     EXPECT_TRUE(has1);
376     manager->executors_->Remove(taskId1);
377     manager->objectTimer_.Clear();
378     manager->restoreStatus_.Clear();
379 
380     manager->restoreStatus_.Insert(objectKey, RestoreStatus::ASSETS_READY);
381     manager->ComputeStatus(objectKey, {}, data);
382     auto [has2, value2] = manager->restoreStatus_.Find(objectKey);
383     EXPECT_TRUE(has2);
384     EXPECT_EQ(value2, RestoreStatus::ALL_READY);
385     auto [has3, taskId3] = manager->objectTimer_.Find(objectKey);
386     EXPECT_FALSE(has3);
387     manager->restoreStatus_.Clear();
388 }
389 
390 /**
391 * @tc.name: Open001
392 * @tc.desc: Open test.
393 * @tc.type: FUNC
394 * @tc.require:
395 * @tc.author: wangbin
396 */
397 HWTEST_F(ObjectManagerTest, Open001, TestSize.Level0)
398 {
399     auto manager = ObjectStoreManager::GetInstance();
400     manager->kvStoreDelegateManager_ = nullptr;
401     auto result = manager->Open();
402     ASSERT_EQ(result, DistributedObject::OBJECT_INNER_ERROR);
403     std::string dataDir = "/data/app/el2/100/database";
404     manager->SetData(dataDir, userId_);
405     manager->delegate_ = nullptr;
406     result = manager->Open();
407     ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
408     manager->delegate_ = manager->OpenObjectKvStore();
409     result = manager->Open();
410     ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
411 }
412 
413 /**
414 * @tc.name: OnAssetChanged001
415 * @tc.desc: OnAssetChanged test.
416 * @tc.type: FUNC
417 * @tc.require:
418 * @tc.author: wangbin
419 */
420 HWTEST_F(ObjectManagerTest, OnAssetChanged001, TestSize.Level0)
421 {
422     auto manager = ObjectStoreManager::GetInstance();
423     std::shared_ptr<Snapshot> snapshot = std::make_shared<ObjectSnapshot>();
424     auto snapshotKey = appId_ + "_" + sessionId_;
425     auto result = manager->OnAssetChanged(tokenId_, appId_, sessionId_, deviceId_, assetValue_);
426     ASSERT_EQ(result, DistributedObject::OBJECT_INNER_ERROR);
427     manager->snapshots_.Insert(snapshotKey, snapshot);
428     result = manager->OnAssetChanged(tokenId_, appId_, sessionId_, deviceId_, assetValue_);
429     ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
430 }
431 
432 /**
433 * @tc.name: DeleteSnapshot001
434 * @tc.desc: DeleteSnapshot test.
435 * @tc.type: FUNC
436 * @tc.require:
437 * @tc.author: wangbin
438 */
439 HWTEST_F(ObjectManagerTest, DeleteSnapshot001, TestSize.Level0)
440 {
441     auto manager = ObjectStoreManager::GetInstance();
442     std::shared_ptr<Snapshot> snapshot = std::make_shared<ObjectSnapshot>();
443     auto snapshotKey = bundleName_ + "_" + sessionId_;
444     auto snapshots = manager->snapshots_.Find(snapshotKey).second;
445     ASSERT_EQ(snapshots, nullptr);
446     manager->DeleteSnapshot(bundleName_, sessionId_);
447 
448     manager->snapshots_.Insert(snapshotKey, snapshot);
449     snapshots = manager->snapshots_.Find(snapshotKey).second;
450     ASSERT_NE(snapshots, nullptr);
451     manager->DeleteSnapshot(bundleName_, sessionId_);
452 }
453 
454 /**
455 * @tc.name: OpenObjectKvStore001
456 * @tc.desc: OpenObjectKvStore test.
457 * @tc.type: FUNC
458 * @tc.require:
459 * @tc.author: wangbin
460 */
461 HWTEST_F(ObjectManagerTest, OpenObjectKvStore001, TestSize.Level0)
462 {
463     auto manager = ObjectStoreManager::GetInstance();
464     manager->objectDataListener_ = nullptr;
465     ASSERT_EQ(manager->objectDataListener_, nullptr);
466     manager->OpenObjectKvStore();
467     ASSERT_NE(manager->objectDataListener_, nullptr);
468     manager->OpenObjectKvStore();
469 }
470 
471 /**
472 * @tc.name: FlushClosedStore001
473 * @tc.desc: FlushClosedStore test.
474 * @tc.type: FUNC
475 * @tc.require:
476 * @tc.author: wangbin
477 */
478 HWTEST_F(ObjectManagerTest, FlushClosedStore001, TestSize.Level0)
479 {
480     auto manager = ObjectStoreManager::GetInstance();
481     manager->isSyncing_ = true;
482     manager->syncCount_ = 10; // test syncCount_
483     manager->delegate_ = nullptr;
484     manager->FlushClosedStore();
485     manager->isSyncing_ = false;
486     manager->FlushClosedStore();
487     manager->syncCount_ = 0; // test syncCount_
488     manager->FlushClosedStore();
489     manager->delegate_ = manager->OpenObjectKvStore();
490     manager->FlushClosedStore();
491 }
492 
493 /**
494 * @tc.name: Close001
495 * @tc.desc: Close test.
496 * @tc.type: FUNC
497 * @tc.require:
498 * @tc.author: wangbin
499 */
500 HWTEST_F(ObjectManagerTest, Close001, TestSize.Level0)
501 {
502     auto manager = ObjectStoreManager::GetInstance();
503     manager->syncCount_ = 1; // test syncCount_
504     manager->Close();
505     ASSERT_EQ(manager->syncCount_, 1); // 1 is for testing
506     manager->delegate_ = manager->OpenObjectKvStore();
507     manager->Close();
508     ASSERT_EQ(manager->syncCount_, 0); // 0 is for testing
509 }
510 
511 /**
512 * @tc.name: SyncOnStore001
513 * @tc.desc: SyncOnStore test.
514 * @tc.type: FUNC
515 * @tc.require:
516 * @tc.author: wangbin
517 */
518 HWTEST_F(ObjectManagerTest, SyncOnStore001, TestSize.Level0)
519 {
520     auto manager = ObjectStoreManager::GetInstance();
521     std::function<void(const std::map<std::string, int32_t> &results)> func;
__anon1296a7d80302(const std::map<std::string, int32_t> &results) 522     func = [](const std::map<std::string, int32_t> &results) {
523         return results;
524     };
525     std::string prefix = "ObjectManagerTest";
526     std::vector<std::string> deviceList;
527     deviceList.push_back("local");
528     deviceList.push_back("local1");
529     auto result = manager->SyncOnStore(prefix, deviceList, func);
530     ASSERT_EQ(result, OBJECT_SUCCESS);
531 }
532 
533 /**
534 * @tc.name: RevokeSaveToStore001
535 * @tc.desc: RetrieveFromStore test.
536 * @tc.type: FUNC
537 * @tc.require:
538 * @tc.author: wangbin
539 */
540 HWTEST_F(ObjectManagerTest, RevokeSaveToStore001, TestSize.Level0)
541 {
542     auto manager = ObjectStoreManager::GetInstance();
543     DistributedDB::KvStoreNbDelegateMock mockDelegate;
544     manager->delegate_ = &mockDelegate;
545     std::vector<uint8_t> id;
546     id.push_back(1);  // for testing
547     id.push_back(2);  // for testing
548     std::map<std::string, std::vector<uint8_t>> results;
549     results = {{ "test_cloud", id }};
550     auto result = manager->RetrieveFromStore(appId_, sessionId_, results);
551     ASSERT_EQ(result, OBJECT_SUCCESS);
552 }
553 
554 /**
555 * @tc.name: SyncCompleted001
556 * @tc.desc: SyncCompleted test.
557 * @tc.type: FUNC
558 * @tc.require:
559 * @tc.author: wangbin
560 */
561 HWTEST_F(ObjectManagerTest, SyncCompleted001, TestSize.Level0)
562 {
563     auto manager = ObjectStoreManager::GetInstance();
564     auto syncManager = SequenceSyncManager::GetInstance();
565     std::map<std::string, DistributedDB::DBStatus> results;
566     results = {{ "test_cloud", DistributedDB::DBStatus::OK }};
567     std::function<void(const std::map<std::string, int32_t> &results)> func;
__anon1296a7d80402(const std::map<std::string, int32_t> &results) 568     func = [](const std::map<std::string, int32_t> &results) {
569         return results;
570     };
571     manager->userId_ = "99";
572     std::vector<uint64_t> userId;
573     userId.push_back(99);
574     userId.push_back(100);
575     manager->SyncCompleted(results, sequenceId_);
576     syncManager->userIdSeqIdRelations_ = {{ "test_cloud", userId }};
577     manager->SyncCompleted(results, sequenceId_);
578     userId.clear();
579     syncManager->seqIdCallbackRelations_.emplace(sequenceId_, func);
580     manager->SyncCompleted(results, sequenceId_);
581     userId.push_back(99);
582     userId.push_back(100);
583     manager->SyncCompleted(results, sequenceId_);
584 }
585 
586 /**
587 * @tc.name: SplitEntryKey001
588 * @tc.desc: SplitEntryKey test.
589 * @tc.type: FUNC
590 * @tc.require:
591 * @tc.author: wangbin
592 */
593 HWTEST_F(ObjectManagerTest, SplitEntryKey001, TestSize.Level0)
594 {
595     auto manager = ObjectStoreManager::GetInstance();
596     std::string key1 = "";
597     std::string key2 = "ObjectManagerTest";
598     auto result = manager->SplitEntryKey(key1);
599     ASSERT_EQ(result.empty(), true);
600     result = manager->SplitEntryKey(key2);
601     ASSERT_EQ(result.empty(), true);
602 }
603 
604 /**
605 * @tc.name: SplitEntryKey002
606 * @tc.desc: SplitEntryKey test.
607 * @tc.type: FUNC
608 */
609 HWTEST_F(ObjectManagerTest, SplitEntryKey002, TestSize.Level0)
610 {
611     auto manager = ObjectStoreManager::GetInstance();
612     std::string key1 = "com.example.myapplication_sessionId_source_target_1234567890_p_propertyName";
613     auto res = manager->SplitEntryKey(key1);
614     EXPECT_EQ(res[0], "com.example.myapplication");
615     EXPECT_EQ(res[1], "sessionId");
616     EXPECT_EQ(res[2], "source");
617     EXPECT_EQ(res[3], "target");
618     EXPECT_EQ(res[4], "1234567890");
619     EXPECT_EQ(res[5], "p_propertyName");
620 
621     std::string key2 = "com.example.myapplication_sessionId_source_target_000_p_propertyName";
622     res = manager->SplitEntryKey(key2);
623     EXPECT_TRUE(res.empty());
624 
625     std::string key3 = "com.example.myapplicationsessionIdsourcetarget_1234567890_p_propertyName";
626     res = manager->SplitEntryKey(key3);
627     EXPECT_TRUE(res.empty());
628 
629     std::string key4 = "com.example.myapplicationsessionIdsource_target_1234567890_p_propertyName";
630     res = manager->SplitEntryKey(key4);
631     EXPECT_TRUE(res.empty());
632 
633     std::string key5 = "com.example.myapplicationsessionId_source_target_1234567890_p_propertyName";
634     res = manager->SplitEntryKey(key5);
635     EXPECT_TRUE(res.empty());
636 }
637 
638 /**
639 * @tc.name: ProcessOldEntry001
640 * @tc.desc: ProcessOldEntry test.
641 * @tc.type: FUNC
642 * @tc.require:
643 * @tc.author: wangbin
644 */
645 HWTEST_F(ObjectManagerTest, ProcessOldEntry001, TestSize.Level0)
646 {
647     auto manager = ObjectStoreManager::GetInstance();
648     manager->delegate_ = manager->OpenObjectKvStore();
649     std::vector<DistributedDB::Entry> entries;
650     auto status = manager->delegate_->GetEntries(std::vector<uint8_t>(appId_.begin(), appId_.end()), entries);
651     ASSERT_EQ(status, DistributedDB::DBStatus::NOT_FOUND);
652     manager->ProcessOldEntry(appId_);
653 
654     DistributedDB::KvStoreNbDelegateMock mockDelegate;
655     manager->delegate_ = &mockDelegate;
656     status = manager->delegate_->GetEntries(std::vector<uint8_t>(appId_.begin(), appId_.end()), entries);
657     ASSERT_EQ(status, DistributedDB::DBStatus::OK);
658     manager->ProcessOldEntry(appId_);
659 }
660 
661 /**
662 * @tc.name: ProcessSyncCallback001
663 * @tc.desc: ProcessSyncCallback test.
664 * @tc.type: FUNC
665 * @tc.require:
666 * @tc.author: wangbin
667 */
668 HWTEST_F(ObjectManagerTest, ProcessSyncCallback001, TestSize.Level0)
669 {
670     auto manager = ObjectStoreManager::GetInstance();
671     std::map<std::string, int32_t> results;
672     manager->ProcessSyncCallback(results, appId_, sessionId_, deviceId_);
673     results.insert({"local", 1}); // for testing
674     ASSERT_EQ(results.empty(), false);
675     ASSERT_NE(results.find("local"), results.end());
676     manager->ProcessSyncCallback(results, appId_, sessionId_, deviceId_);
677 }
678 
679 /**
680 * @tc.name: IsAssetComplete001
681 * @tc.desc: IsAssetComplete test.
682 * @tc.type: FUNC
683 * @tc.require:
684 * @tc.author: wangbin
685 */
686 HWTEST_F(ObjectManagerTest, IsAssetComplete001, TestSize.Level0)
687 {
688     auto manager = ObjectStoreManager::GetInstance();
689     std::map<std::string, std::vector<uint8_t>> results;
690     std::vector<uint8_t> completes;
691     completes.push_back(1); // for testing
692     completes.push_back(2); // for testing
693     std::string assetPrefix = "IsAssetComplete_test";
694     results.insert({assetPrefix, completes});
695     auto result = manager->IsAssetComplete(results, assetPrefix);
696     ASSERT_EQ(result, false);
697     results.insert({assetPrefix + ObjectStore::NAME_SUFFIX, completes});
698     result = manager->IsAssetComplete(results, assetPrefix);
699     ASSERT_EQ(result, false);
700     results.insert({assetPrefix + ObjectStore::URI_SUFFIX, completes});
701     result = manager->IsAssetComplete(results, assetPrefix);
702     ASSERT_EQ(result, false);
703     results.insert({assetPrefix + ObjectStore::PATH_SUFFIX, completes});
704     result = manager->IsAssetComplete(results, assetPrefix);
705     ASSERT_EQ(result, false);
706     results.insert({assetPrefix + ObjectStore::CREATE_TIME_SUFFIX, completes});
707     result = manager->IsAssetComplete(results, assetPrefix);
708     ASSERT_EQ(result, false);
709     results.insert({assetPrefix + ObjectStore::MODIFY_TIME_SUFFIX, completes});
710     result = manager->IsAssetComplete(results, assetPrefix);
711     ASSERT_EQ(result, false);
712     results.insert({assetPrefix + ObjectStore::SIZE_SUFFIX, completes});
713     result = manager->IsAssetComplete(results, assetPrefix);
714     ASSERT_EQ(result, true);
715 }
716 
717 /**
718 * @tc.name: GetAssetsFromDBRecords001
719 * @tc.desc: GetAssetsFromDBRecords test.
720 * @tc.type: FUNC
721 * @tc.require:
722 * @tc.author: wangbin
723 */
724 HWTEST_F(ObjectManagerTest, GetAssetsFromDBRecords001, TestSize.Level0)
725 {
726     auto manager = ObjectStoreManager::GetInstance();
727     std::map<std::string, std::vector<uint8_t>> results;
728     std::vector<uint8_t> completes;
729     completes.push_back(1); // for testing
730     completes.push_back(2); // for testing
731     std::string assetPrefix = "IsAssetComplete_test";
732     results.insert({assetPrefix, completes});
733     results.insert({assetPrefix + ObjectStore::NAME_SUFFIX, completes});
734     results.insert({assetPrefix + ObjectStore::URI_SUFFIX, completes});
735     results.insert({assetPrefix + ObjectStore::MODIFY_TIME_SUFFIX, completes});
736     results.insert({assetPrefix + ObjectStore::SIZE_SUFFIX, completes});
737     auto result = manager->GetAssetsFromDBRecords(results);
738     ASSERT_EQ(result.empty(), false);
739 }
740 
741 /**
742 * @tc.name: GetAssetsFromDBRecords002
743 * @tc.desc: GetAssetsFromDBRecords test.
744 * @tc.type: FUNC
745 */
746 HWTEST_F(ObjectManagerTest, GetAssetsFromDBRecords002, TestSize.Level0)
747 {
748     auto manager = ObjectStoreManager::GetInstance();
749     std::map<std::string, std::vector<uint8_t>> result;
750 
751     std::vector<uint8_t> value0{0};
752     std::string data0 = "[STRING]test";
753     value0.insert(value0.end(), data0.begin(), data0.end());
754 
755     std::vector<uint8_t> value1{0};
756     std::string data1 = "(string)test";
757     value1.insert(value1.end(), data1.begin(), data1.end());
758 
759     std::string prefix = "bundleName_sessionId_source_target_timestamp";
760     std::string dataKey = prefix + "_p_data";
761     std::string assetPrefix0 = prefix + "_p_asset0";
762     std::string assetPrefix1 = prefix + "_p_asset1";
763 
764     result.insert({dataKey, value0});
765     auto assets = manager->GetAssetsFromDBRecords(result);
766     EXPECT_TRUE(assets.empty());
767 
768     result.clear();
769     result.insert({assetPrefix0 + ObjectStore::URI_SUFFIX, value0});
770     assets = manager->GetAssetsFromDBRecords(result);
771     EXPECT_TRUE(assets.empty());
772 
773     result.clear();
774     result.insert({assetPrefix1 + ObjectStore::NAME_SUFFIX, value1});
775     assets = manager->GetAssetsFromDBRecords(result);
776     EXPECT_TRUE(assets.empty());
777 
778     result.clear();
779     result.insert({assetPrefix0 + ObjectStore::NAME_SUFFIX, value0});
780     result.insert({assetPrefix0 + ObjectStore::URI_SUFFIX, value0});
781     result.insert({assetPrefix0 + ObjectStore::MODIFY_TIME_SUFFIX, value0});
782     result.insert({assetPrefix0 + ObjectStore::SIZE_SUFFIX, value0});
783     assets = manager->GetAssetsFromDBRecords(result);
784     ASSERT_EQ(assets.size(), 1);
785     EXPECT_EQ(assets[0].name, "test");
786     EXPECT_EQ(assets[0].uri, "test");
787     EXPECT_EQ(assets[0].modifyTime, "test");
788     EXPECT_EQ(assets[0].size, "test");
789     EXPECT_EQ(assets[0].hash, "test_test");
790 
791     result.clear();
792     result.insert({assetPrefix1 + ObjectStore::NAME_SUFFIX, value1});
793     result.insert({assetPrefix1 + ObjectStore::URI_SUFFIX, value1});
794     result.insert({assetPrefix1 + ObjectStore::MODIFY_TIME_SUFFIX, value1});
795     result.insert({assetPrefix1 + ObjectStore::SIZE_SUFFIX, value1});
796     assets = manager->GetAssetsFromDBRecords(result);
797     ASSERT_EQ(assets.size(), 1);
798     EXPECT_EQ(assets[0].name, "(string)test");
799     EXPECT_EQ(assets[0].uri, "(string)test");
800     EXPECT_EQ(assets[0].modifyTime, "(string)test");
801     EXPECT_EQ(assets[0].size, "(string)test");
802     EXPECT_EQ(assets[0].hash, "(string)test_(string)test");
803 }
804 
805 /**
806 * @tc.name: RegisterAssetsLister001
807 * @tc.desc: RegisterAssetsLister test.
808 * @tc.type: FUNC
809 * @tc.require:
810 * @tc.author: wangbin
811 */
812 HWTEST_F(ObjectManagerTest, RegisterAssetsLister001, TestSize.Level0)
813 {
814     auto manager = ObjectStoreManager::GetInstance();
815     manager->objectAssetsSendListener_ = nullptr;
816     manager->objectAssetsRecvListener_ = nullptr;
817     auto result = manager->RegisterAssetsLister();
818     ASSERT_EQ(result, true);
819     manager->objectAssetsSendListener_ = new ObjectAssetsSendListener();
820     manager->objectAssetsRecvListener_ = new ObjectAssetsRecvListener();;
821     result = manager->RegisterAssetsLister();
822     ASSERT_EQ(result, true);
823 }
824 
825 /**
826 * @tc.name: RegisterAssetsLister001
827 * @tc.desc: PushAssets test.
828 * @tc.type: FUNC
829 * @tc.require:
830 * @tc.author: wangbin
831 */
832 HWTEST_F(ObjectManagerTest, PushAssets001, TestSize.Level0)
833 {
834     auto manager = ObjectStoreManager::GetInstance();
835     std::map<std::string, std::vector<uint8_t>> data;
836     std::string assetPrefix = "PushAssets_test";
837     std::vector<uint8_t> completes;
838     completes.push_back(1); // for testing
839     completes.push_back(2); // for testing
840     data.insert({assetPrefix, completes});
841     auto result = manager->PushAssets(appId_, appId_, sessionId_, data, deviceId_);
842     ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
843 }
844 
845 /**
846 * @tc.name: AddNotifier001
847 * @tc.desc: AddNotifie and DeleteNotifier test.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(ObjectManagerTest, AddNotifier001, TestSize.Level0)
851 {
852     auto syncManager = SequenceSyncManager::GetInstance();
853     std::function<void(const std::map<std::string, int32_t> &results)> func;
__anon1296a7d80502(const std::map<std::string, int32_t> &results) 854     func = [](const std::map<std::string, int32_t> &results) {
855         return results;
856     };
857     auto sequenceId_ = syncManager->AddNotifier(userId_, func);
858     auto result = syncManager->DeleteNotifier(sequenceId_, userId_);
859     ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_HAS_FINISHED);
860 }
861 
862 /**
863 * @tc.name: AddNotifier002
864 * @tc.desc: AddNotifie and DeleteNotifier test.
865 * @tc.type: FUNC
866 */
867 HWTEST_F(ObjectManagerTest, AddNotifier002, TestSize.Level0)
868 {
869     auto syncManager = SequenceSyncManager::GetInstance();
870     std::function<void(const std::map<std::string, int32_t> &results)> func;
__anon1296a7d80602(const std::map<std::string, int32_t> &results) 871     func = [](const std::map<std::string, int32_t> &results) {
872         return results;
873     };
874     auto sequenceId = syncManager->AddNotifier(userId_, func);
875     ASSERT_NE(sequenceId, sequenceId_);
876     auto result = syncManager->DeleteNotifier(sequenceId_, userId_);
877     ASSERT_EQ(result, SequenceSyncManager::ERR_SID_NOT_EXIST);
878 }
879 
880 /**
881 * @tc.name: BindAsset 001
882 * @tc.desc: BindAsset test.
883 * @tc.type: FUNC
884 */
885 HWTEST_F(ObjectManagerTest, BindAsset001, TestSize.Level0)
886 {
887     auto manager = ObjectStoreManager::GetInstance();
888     std::string bundleName = "BindAsset";
889     uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
890     auto result = manager->BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_);
891     ASSERT_EQ(result, DistributedObject::OBJECT_DBSTATUS_ERROR);
892 }
893 } // namespace OHOS::Test
894