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