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 #define LOG_TAG "KvdbServiceImplTest"
16 #include "kvdb_service_impl.h"
17
18 #include <gtest/gtest.h>
19 #include <gmock/gmock.h>
20 #include <vector>
21
22 #include "bootstrap.h"
23 #include "checker/checker_manager.h"
24 #include "cloud/cloud_event.h"
25 #include "cloud/cloud_server.h"
26 #include "device_manager_adapter.h"
27 #include "distributed_kv_data_manager.h"
28 #include "event_center.h"
29 #include "ipc_skeleton.h"
30 #include "kvdb_service_stub.h"
31 #include "kvstore_death_recipient.h"
32 #include "kvstore_meta_manager.h"
33 #include "kvstore_sync_manager.h"
34 #include "log_print.h"
35 #include "mock/access_token_mock.h"
36 #include "mock/meta_data_manager_mock.h"
37 #include "network_delegate.h"
38 #include "network_delegate_mock.h"
39 #include "nativetoken_kit.h"
40 #include "token_setproc.h"
41 #include "types.h"
42 #include "utils/anonymous.h"
43 #include "utils/constant.h"
44
45 using namespace testing::ext;
46 using namespace OHOS::DistributedData;
47 using namespace OHOS::Security::AccessToken;
48 using Action = OHOS::DistributedData::MetaDataManager::Action;
49 using AppId = OHOS::DistributedKv::AppId;
50 using ChangeType = OHOS::DistributedData::DeviceMatrix::ChangeType;
51 using DistributedKvDataManager = OHOS::DistributedKv::DistributedKvDataManager;
52 using DBStatus = DistributedDB::DBStatus;
53 using DBMode = DistributedDB::SyncMode;
54 using Options = OHOS::DistributedKv::Options;
55 using Status = OHOS::DistributedKv::Status;
56 using SingleKvStore = OHOS::DistributedKv::SingleKvStore;
57 using StoreId = OHOS::DistributedKv::StoreId;
58 using SyncInfo = OHOS::DistributedKv::KVDBService::SyncInfo;
59 using SyncMode = OHOS::DistributedKv::SyncMode;
60 using SyncAction = OHOS::DistributedKv::KVDBServiceImpl::SyncAction;
61 using SwitchState = OHOS::DistributedKv::SwitchState;
62 using UserId = OHOS::DistributedKv::UserId;
63 using StoreMetaData = OHOS::DistributedData::StoreMetaData;
64 using SyncEnd = OHOS::DistributedKv::KvStoreSyncManager::SyncEnd;
65 using DBResult = std::map<std::string, DistributedDB::DBStatus>;
66 static OHOS::DistributedKv::StoreId storeId = { "kvdb_test_storeid" };
67 static OHOS::DistributedKv::AppId appId = { "ohos.test.kvdb" };
68
69 namespace OHOS::Test {
70 namespace DistributedDataTest {
71 class KvdbServiceImplTest : public testing::Test {
72 public:
73 static inline std::shared_ptr<AccessTokenKitMock> accTokenMock = nullptr;
74 static inline std::shared_ptr<MetaDataManagerMock> metaDataManagerMock = nullptr;
75 static constexpr size_t NUM_MIN = 5;
76 static constexpr size_t NUM_MAX = 12;
77 static DistributedKvDataManager manager;
78 static Options create;
79 static UserId userId;
80
81 std::shared_ptr<SingleKvStore> kvStore;
82
83 static AppId appId;
84 static StoreId storeId64;
85 static StoreId storeId65;
86
87 static void SetUpTestCase(void);
88 static void TearDownTestCase(void);
89 static void RemoveAllStore(OHOS::DistributedKv::DistributedKvDataManager &manager);
90 void SetUp();
91 void TearDown();
92
93 KvdbServiceImplTest();
94
95 protected:
96 std::shared_ptr<DistributedKv::KVDBServiceImpl> kvdbServiceImpl_;
97 static NetworkDelegateMock delegate_;
98 };
99
100 class CloudServerMock : public CloudServer {
101 public:
102 virtual ~CloudServerMock() = default;
103 bool IsSupportCloud(int32_t userId);
104 };
105
IsSupportCloud(int32_t userId)106 bool CloudServerMock::IsSupportCloud(int32_t userId)
107 {
108 return true;
109 }
110
111 OHOS::DistributedKv::DistributedKvDataManager KvdbServiceImplTest::manager;
112 Options KvdbServiceImplTest::create;
113 UserId KvdbServiceImplTest::userId;
114
115 AppId KvdbServiceImplTest::appId;
116 StoreId KvdbServiceImplTest::storeId64;
117 StoreId KvdbServiceImplTest::storeId65;
118 NetworkDelegateMock KvdbServiceImplTest::delegate_;
119
RemoveAllStore(DistributedKvDataManager & manager)120 void KvdbServiceImplTest::RemoveAllStore(DistributedKvDataManager &manager)
121 {
122 manager.CloseAllKvStore(appId);
123 manager.DeleteAllKvStore(appId, create.baseDir);
124 }
125
SetUpTestCase(void)126 void KvdbServiceImplTest::SetUpTestCase(void)
127 {
128 auto executors = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
129 manager.SetExecutors(executors);
130 userId.userId = "kvdbserviceimpltest1";
131 appId.appId = "ohos.kvdbserviceimpl.test";
132 create.createIfMissing = true;
133 create.encrypt = false;
134 create.securityLevel = OHOS::DistributedKv::S1;
135 create.autoSync = true;
136 create.kvStoreType = OHOS::DistributedKv::SINGLE_VERSION;
137 create.area = OHOS::DistributedKv::EL1;
138 create.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
139 mkdir(create.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
140
141 storeId64.storeId = "a000000000b000000000c000000000d000000000e000000000f000000000g000";
142 storeId65.storeId = "a000000000b000000000c000000000d000000000e000000000f000000000g000"
143 "a000000000b000000000c000000000d000000000e000000000f000000000g0000";
144 RemoveAllStore(manager);
145
146 accTokenMock = std::make_shared<AccessTokenKitMock>();
147 BAccessTokenKit::accessTokenkit = accTokenMock;
148 metaDataManagerMock = std::make_shared<MetaDataManagerMock>();
149 BMetaDataManager::metaDataManager = metaDataManagerMock;
150 NetworkDelegate::RegisterNetworkInstance(&delegate_);
151 }
152
TearDownTestCase()153 void KvdbServiceImplTest::TearDownTestCase()
154 {
155 RemoveAllStore(manager);
156 (void)remove((create.baseDir + "/kvdb").c_str());
157 (void)remove(create.baseDir.c_str());
158
159 accTokenMock = nullptr;
160 BAccessTokenKit::accessTokenkit = nullptr;
161 metaDataManagerMock = nullptr;
162 BMetaDataManager::metaDataManager = nullptr;
163 }
164
SetUp(void)165 void KvdbServiceImplTest::SetUp(void)
166 {
167 kvdbServiceImpl_ = std::make_shared<DistributedKv::KVDBServiceImpl>();
168 }
169
TearDown(void)170 void KvdbServiceImplTest::TearDown(void)
171 {
172 RemoveAllStore(manager);
173 }
174
SyncEndCallback(const std::map<std::string,DistributedDB::DBStatus> & statusMap)175 void SyncEndCallback(const std::map<std::string, DistributedDB::DBStatus> &statusMap)
176 {
177 for (const auto &pair : statusMap) {
178 ZLOGI("Key: %{public}s, Status: %{public}d", pair.first.c_str(), pair.second);
179 }
180 }
181
KvdbServiceImplTest(void)182 KvdbServiceImplTest::KvdbServiceImplTest(void) {}
183
184 /**
185 * @tc.name: KvdbServiceImpl001
186 * @tc.desc: KvdbServiceImplTest function test.
187 * @tc.type: FUNC
188 * @tc.author: SQL
189 */
190 HWTEST_F(KvdbServiceImplTest, KvdbServiceImpl001, TestSize.Level0)
191 {
192 std::string device = "OH_device_test";
193 StoreId id1;
194 id1.storeId = "id1";
195 Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
196 EXPECT_NE(kvStore, nullptr);
197 EXPECT_EQ(status, Status::SUCCESS);
198 int32_t result = kvdbServiceImpl_->OnInitialize();
199 EXPECT_EQ(result, Status::SUCCESS);
200 FeatureSystem::Feature::BindInfo bindInfo;
201 result = kvdbServiceImpl_->OnBind(bindInfo);
202 EXPECT_EQ(result, Status::SUCCESS);
203 result = kvdbServiceImpl_->Online(device);
204 EXPECT_EQ(result, Status::SUCCESS);
205 status = kvdbServiceImpl_->SubscribeSwitchData(appId);
206 EXPECT_EQ(status, Status::SUCCESS);
207 SyncInfo syncInfo;
208 status = kvdbServiceImpl_->CloudSync(appId, id1, syncInfo);
209 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
210
211 DistributedKv::StoreConfig storeConfig;
212 status = kvdbServiceImpl_->SetConfig(appId, id1, storeConfig);
213 EXPECT_EQ(status, Status::SUCCESS);
214 status = kvdbServiceImpl_->NotifyDataChange(appId, id1, 0);
215 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
216
217 status = kvdbServiceImpl_->UnsubscribeSwitchData(appId);
218 EXPECT_EQ(status, Status::SUCCESS);
219
220 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return
221 (ATokenTypeEnum::TOKEN_NATIVE)).WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
222 status = kvdbServiceImpl_->Close(appId, id1, 0);
223 EXPECT_EQ(status, Status::SUCCESS);
224 }
225
226 /**
227 * @tc.name: OnInitialize001
228 * @tc.desc: OnInitialize function test.
229 * @tc.type: FUNC
230 * @tc.author: wangbin
231 */
232 HWTEST_F(KvdbServiceImplTest, OnInitialize001, TestSize.Level0)
233 {
234 std::string device = "OH_device_test";
235 int32_t result = kvdbServiceImpl_->OnInitialize();
236 EXPECT_EQ(result, Status::SUCCESS);
237 DistributedData::StoreInfo storeInfo;
238 storeInfo.bundleName = appId.appId;
239 storeInfo.storeName = storeId.storeId;
240 storeInfo.instanceId = 10;
241 storeInfo.user = 100;
242 auto event = std::make_unique<CloudEvent>(CloudEvent::CLOUD_SYNC, storeInfo);
243 EXPECT_NE(event, nullptr);
244 result = EventCenter::GetInstance().PostEvent(move(event));
245 EXPECT_EQ(result, 1); // CODE_SYNC
246 auto event1 = std::make_unique<CloudEvent>(CloudEvent::CLEAN_DATA, storeInfo);
247 EXPECT_NE(event1, nullptr);
248 result = EventCenter::GetInstance().PostEvent(move(event1));
249 EXPECT_EQ(result, 1); // CODE_SYNC
250 }
251
252 /**
253 * @tc.name: GetStoreIdsTest001
254 * @tc.desc: GetStoreIds
255 * @tc.type: FUNC
256 * @tc.author: wangbin
257 */
258 HWTEST_F(KvdbServiceImplTest, GetStoreIdsTest001, TestSize.Level0)
259 {
260 ZLOGI("GetStoreIdsTest001 start");
261 StoreId id1;
262 id1.storeId = "id1";
263 StoreId id2;
264 id2.storeId = "id2";
265 StoreId id3;
266 id3.storeId = "id3";
267 Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
268 ASSERT_NE(kvStore, nullptr);
269 ASSERT_EQ(status, Status::SUCCESS);
270 status = manager.GetSingleKvStore(create, appId, id2, kvStore);
271 ASSERT_NE(kvStore, nullptr);
272 ASSERT_EQ(status, Status::SUCCESS);
273 status = manager.GetSingleKvStore(create, appId, id3, kvStore);
274 ASSERT_NE(kvStore, nullptr);
275 ASSERT_EQ(status, Status::SUCCESS);
276 std::vector<StoreId> storeIds;
277 status = kvdbServiceImpl_->GetStoreIds(appId, 0, storeIds);
278 ASSERT_EQ(status, Status::SUCCESS);
279 }
280
281 /**
282 * @tc.name: GetStoreIdsTest002
283 * @tc.desc: GetStoreIds
284 * @tc.type: FUNC
285 * @tc.author: wangbin
286 */
287 HWTEST_F(KvdbServiceImplTest, GetStoreIdsTest002, TestSize.Level0)
288 {
289 ZLOGI("GetStoreIdsTest002 start");
290 std::vector<StoreId> storeIds;
291 AppId appId01;
292 auto status = kvdbServiceImpl_->GetStoreIds(appId01, 0, storeIds);
293 ZLOGI("GetStoreIdsTest002 status = :%{public}d", status);
294 ASSERT_EQ(status, Status::SUCCESS);
295 }
296
297 /**
298 * @tc.name: DeleteTest001
299 * @tc.desc: Delete Test
300 * @tc.type: FUNC
301 * @tc.author: wangbin
302 */
303 HWTEST_F(KvdbServiceImplTest, DeleteTest001, TestSize.Level0)
304 {
305 ZLOGI("DeleteTest001 start");
306 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
307 ASSERT_NE(kvStore, nullptr);
308 ASSERT_EQ(status1, Status::SUCCESS);
309 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return
310 (ATokenTypeEnum::TOKEN_NATIVE)).WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
311 auto status = kvdbServiceImpl_->Delete(appId, storeId, 0);
312 ZLOGI("DeleteTest001 status = :%{public}d", status);
313 ASSERT_EQ(status, Status::SUCCESS);
314 }
315
316 /**
317 * @tc.name: DeleteTest002
318 * @tc.desc: Delete Test
319 * @tc.type: FUNC
320 * @tc.author: wangbin
321 */
322 HWTEST_F(KvdbServiceImplTest, DeleteTest002, TestSize.Level0)
323 {
324 ZLOGI("DeleteTest002 start");
325 AppId appId01 = { "ohos.kvdbserviceimpl.test01" };
326 StoreId storeId01 = { "meta_test_storeid" };
327 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return
328 (ATokenTypeEnum::TOKEN_NATIVE)).WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
329 auto status = kvdbServiceImpl_->Delete(appId01, storeId01, 0);
330 ZLOGI("DeleteTest002 status = :%{public}d", status);
331 ASSERT_EQ(status, Status::SUCCESS);
332 }
333
334 /**
335 * @tc.name: DeleteTest003
336 * @tc.desc: Delete function test.
337 * @tc.type: FUNC
338 * @tc.author: wangbin
339 */
340 HWTEST_F(KvdbServiceImplTest, DeleteTest003, TestSize.Level0)
341 {
342 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
343 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
344 EXPECT_CALL(*accTokenMock, GetHapTokenInfo(testing::_, testing::_)).WillOnce(testing::Return(-1))
345 .WillRepeatedly(testing::Return(-1));
346 int32_t status = kvdbServiceImpl_->Delete(appId, storeId, 0);
347 EXPECT_EQ(status, DistributedKv::ILLEGAL_STATE);
348 }
349
350 /**
351 * @tc.name: CloseTest001
352 * @tc.desc: Close function test.
353 * @tc.type: FUNC
354 * @tc.author: wangbin
355 */
356 HWTEST_F(KvdbServiceImplTest, CloseTest001, TestSize.Level0)
357 {
358 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
359 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
360 EXPECT_CALL(*accTokenMock, GetHapTokenInfo(testing::_, testing::_)).WillOnce(testing::Return(-1))
361 .WillRepeatedly(testing::Return(-1));
362 int32_t status = kvdbServiceImpl_->Close(appId, storeId, 0);
363 EXPECT_EQ(status, DistributedKv::ILLEGAL_STATE);
364 }
365
366 /**
367 * @tc.name: OnAsyncCompleteTest001
368 * @tc.desc: OnAsyncComplete function test.
369 * @tc.type: FUNC
370 * @tc.author: wangbin
371 */
372 HWTEST_F(KvdbServiceImplTest, OnAsyncCompleteTest001, TestSize.Level0)
373 {
374 DistributedKv::Statistic upload;
375 upload.failed = 1; // test
376 upload.success = 1; // test
377 upload.total = 1; // test
378 upload.untreated = 1; // test
379 DistributedKv::Statistic download;
380 download.failed = 1; // test
381 download.success = 1; // test
382 download.total = 1; // test
383 download.untreated = 1; // test
384 DistributedKv::TableDetail details;
385 details.download = download;
386 details.upload = upload;
387 DistributedKv::ProgressDetail detail;
388 detail.code = 1; // test
389 detail.progress = 1; // test
390 detail.details = details;
391 sptr<DistributedKv::IKVDBNotifier> notifier;
392 DistributedKv::KVDBServiceImpl::SyncAgent syncAgent;
393 syncAgent.pid_ = 1; // test
394 syncAgent.switchesObserverCount_ = 1; // test
395 syncAgent.appId_ = { "ohos.OnAsyncCompleteTest001.kvdb" };
396 syncAgent.notifier_ = notifier;
397 kvdbServiceImpl_->syncAgents_.Insert(100, syncAgent); // test
398 kvdbServiceImpl_->OnAsyncComplete(1, 1, std::move(detail)); // test
399 EXPECT_EQ(kvdbServiceImpl_->syncAgents_.Find(1).first, false);
400 kvdbServiceImpl_->OnAsyncComplete(100, 1, std::move(detail)); // test
401 EXPECT_EQ(kvdbServiceImpl_->syncAgents_.Find(100).first, true);
402 }
403
404 /**
405 * @tc.name: syncTest001
406 * @tc.desc: GetStoreIds
407 * @tc.type: FUNC
408 * @tc.author: wangbin
409 */
410 HWTEST_F(KvdbServiceImplTest, syncTest001, TestSize.Level0)
411 {
412 ZLOGI("syncTest001 start");
413 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
414 ASSERT_NE(kvStore, nullptr);
415 ASSERT_EQ(status1, Status::SUCCESS);
416 SyncInfo syncInfo;
417 auto status = kvdbServiceImpl_->Sync(appId, storeId, 0, syncInfo);
418 ZLOGI("syncTest001 status = :%{public}d", status);
419 ASSERT_NE(status, Status::SUCCESS);
420 }
421
422 /**
423 * @tc.name: RegisterSyncCallbackTest001
424 * @tc.desc: GetStoreIds
425 * @tc.type: FUNC
426 * @tc.author: wangbin
427 */
428 HWTEST_F(KvdbServiceImplTest, RegisterSyncCallbackTest001, TestSize.Level0)
429 {
430 ZLOGI("RegisterSyncCallbackTest001 start");
431 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
432 ASSERT_NE(kvStore, nullptr);
433 ASSERT_EQ(status1, Status::SUCCESS);
434 sptr<OHOS::DistributedKv::IKVDBNotifier> notifier;
435 auto status = kvdbServiceImpl_->RegServiceNotifier(appId, notifier);
436 ZLOGI("RegisterSyncCallbackTest001 status = :%{public}d", status);
437 ASSERT_EQ(status, Status::SUCCESS);
438 }
439
440 /**
441 * @tc.name: UnregServiceNotifierTest001
442 * @tc.desc: UnregServiceNotifier test
443 * @tc.type: FUNC
444 * @tc.author: wangbin
445 */
446 HWTEST_F(KvdbServiceImplTest, UnregServiceNotifierTest001, TestSize.Level0)
447 {
448 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
449 ASSERT_NE(kvStore, nullptr);
450 ASSERT_EQ(status1, Status::SUCCESS);
451 sptr<DistributedKv::IKVDBNotifier> notifier;
452 DistributedKv::KVDBServiceImpl::SyncAgent syncAgent;
453 syncAgent.pid_ = 1; // test
454 syncAgent.switchesObserverCount_ = 1; // test
455 syncAgent.appId_ = { "ohos.OnAsyncCompleteTest001.kvdb" };
456 syncAgent.notifier_ = notifier;
457 kvdbServiceImpl_->syncAgents_.Insert(IPCSkeleton::GetCallingTokenID(), syncAgent);
458 auto status = kvdbServiceImpl_->UnregServiceNotifier(appId);
459 ASSERT_EQ(status, Status::SUCCESS);
460 }
461
462 /**
463 * @tc.name: HandleGenDetailsTest001
464 * @tc.desc: HandleGenDetails test
465 * @tc.type: FUNC
466 * @tc.author: wangbin
467 */
468 HWTEST_F(KvdbServiceImplTest, HandleGenDetailsTest001, TestSize.Level0)
469 {
470 DistributedData::GenDetails details;
471 ASSERT_EQ(details.begin(), details.end());
472 DistributedKv::ProgressDetail progressDetails = kvdbServiceImpl_->HandleGenDetails(details);
473 GenProgressDetail detail;
474 detail.progress = GenProgress::SYNC_IN_PROGRESS;
475 detail.code = GenProgress::SYNC_IN_PROGRESS;
476 details.insert_or_assign("test", detail);
477 progressDetails = kvdbServiceImpl_->HandleGenDetails(details);
478 ASSERT_EQ(detail.details.begin(), detail.details.end());
479 ASSERT_EQ(progressDetails.progress, GenProgress::SYNC_IN_PROGRESS);
480 std::map<std::string, GenTableDetail> gentabledetail;
481 GenTableDetail tabledetail;
482 gentabledetail.insert_or_assign("test", tabledetail);
483 detail.details = gentabledetail;
484 progressDetails = kvdbServiceImpl_->HandleGenDetails(details);
485 ASSERT_NE(detail.details.begin(), detail.details.end());
486 ASSERT_EQ(progressDetails.code, GenProgress::SYNC_IN_PROGRESS);
487 }
488
489 /**
490 * @tc.name: SetSyncParamTest001
491 * @tc.desc: SetSyncParam test
492 * @tc.type: FUNC
493 * @tc.author: wangbin
494 */
495 HWTEST_F(KvdbServiceImplTest, SetSyncParamTest001, TestSize.Level0)
496 {
497 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
498 ASSERT_NE(kvStore, nullptr);
499 ASSERT_EQ(status1, Status::SUCCESS);
500 OHOS::DistributedKv::KvSyncParam syncparam;
501 auto status = kvdbServiceImpl_->SetSyncParam(appId, storeId, 0, syncparam);
502 ASSERT_EQ(status, Status::SUCCESS);
503 syncparam.allowedDelayMs = DistributedKv::KvStoreSyncManager::SYNC_MAX_DELAY_MS + 1;
504 status = kvdbServiceImpl_->SetSyncParam(appId, storeId, 0, syncparam);
505 ASSERT_EQ(status, Status::INVALID_ARGUMENT);
506 }
507
508 /**
509 * @tc.name: GetSyncParamTest001
510 * @tc.desc: GetStoreIds
511 * @tc.type: FUNC
512 * @tc.author: wangbin
513 */
514 HWTEST_F(KvdbServiceImplTest, GetSyncParamTest001, TestSize.Level0)
515 {
516 ZLOGI("GetSyncParamTest001 start");
517 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
518 ASSERT_NE(kvStore, nullptr);
519 ASSERT_EQ(status1, Status::SUCCESS);
520 OHOS::DistributedKv::KvSyncParam syncparam;
521 auto status = kvdbServiceImpl_->GetSyncParam(appId, storeId, 0, syncparam);
522 ZLOGI("GetSyncParamTest001 status = :%{public}d", status);
523 ASSERT_EQ(status, Status::SUCCESS);
524 }
525
526 /**
527 * @tc.name: EnableCapabilityTest001
528 * @tc.desc: EnableCapability test
529 * @tc.type: FUNC
530 * @tc.author: wangbin
531 */
532 HWTEST_F(KvdbServiceImplTest, EnableCapabilityTest001, TestSize.Level0)
533 {
534 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
535 ASSERT_NE(kvStore, nullptr);
536 ASSERT_EQ(status1, Status::SUCCESS);
537 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_NATIVE))
538 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
539 auto status = kvdbServiceImpl_->EnableCapability(appId, storeId, 0);
540 ASSERT_EQ(status, Status::SUCCESS);
541 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
542 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
543 status = kvdbServiceImpl_->EnableCapability(appId, storeId, 0);
544 ASSERT_EQ(status, Status::ILLEGAL_STATE);
545 }
546
547 /**
548 * @tc.name: GetInstIndexTest001
549 * @tc.desc: GetInstIndex test
550 * @tc.type: FUNC
551 * @tc.author: wangbin
552 */
553 HWTEST_F(KvdbServiceImplTest, GetInstIndexTest001, TestSize.Level0)
554 {
555 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
556 ASSERT_NE(kvStore, nullptr);
557 ASSERT_EQ(status1, Status::SUCCESS);
558 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
559 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
560 auto status = kvdbServiceImpl_->GetInstIndex(100, appId);
561 ASSERT_EQ(status, -1);
562 }
563
564 /**
565 * @tc.name: IsNeedMetaSyncTest001
566 * @tc.desc: IsNeedMetaSync test
567 * @tc.type: FUNC
568 * @tc.author: wangbin
569 */
570 HWTEST_F(KvdbServiceImplTest, IsNeedMetaSyncTest001, TestSize.Level0)
571 {
572 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
573 ASSERT_NE(kvStore, nullptr);
574 ASSERT_EQ(status1, Status::SUCCESS);
575 StoreMetaData meta = kvdbServiceImpl_->GetStoreMetaData(appId, storeId);
576 std::vector<std::string> uuids{"uuidtest01"};
577 EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
578 .WillOnce(testing::Return(true)).WillRepeatedly(testing::Return(true));
579 auto status = kvdbServiceImpl_->IsNeedMetaSync(meta, uuids);
580 ASSERT_EQ(status, false);
581 EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
582 .WillOnce(testing::Return(false)).WillRepeatedly(testing::Return(false));
583 status = kvdbServiceImpl_->IsNeedMetaSync(meta, uuids);
584 ASSERT_EQ(status, true);
585 }
586
587 /**
588 * @tc.name: GetDistributedDataMetaTest001
589 * @tc.desc: GetDistributedDataMeta test
590 * @tc.type: FUNC
591 * @tc.author: wangbin
592 */
593 HWTEST_F(KvdbServiceImplTest, GetDistributedDataMetaTest001, TestSize.Level0)
594 {
595 Status status = manager.GetSingleKvStore(create, appId, storeId, kvStore);
596 ASSERT_NE(kvStore, nullptr);
597 ASSERT_EQ(status, Status::SUCCESS);
598 std::string deviceId = "KvdbServiceImplTest_deviceId";
599 EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
600 .WillOnce(testing::Return(false)).WillRepeatedly(testing::Return(false));
601 auto meta = kvdbServiceImpl_->GetDistributedDataMeta(deviceId);
602 ASSERT_EQ(meta.user, "0");
603 EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
604 .WillOnce(testing::Return(true)).WillRepeatedly(testing::Return(true));
605 meta = kvdbServiceImpl_->GetDistributedDataMeta(deviceId);
606 ASSERT_EQ(meta.deviceId, deviceId);
607 }
608
609 /**
610 * @tc.name: ProcessResultTest001
611 * @tc.desc: ProcessResult test
612 * @tc.type: FUNC
613 * @tc.author: wangbin
614 */
615 HWTEST_F(KvdbServiceImplTest, ProcessResultTest001, TestSize.Level0)
616 {
617 Status status = manager.GetSingleKvStore(create, appId, storeId, kvStore);
618 ASSERT_NE(kvStore, nullptr);
619 ASSERT_EQ(status, Status::SUCCESS);
620 std::map<std::string, int32_t> results;
621 results.insert_or_assign("uuidtest01", DBStatus::DB_ERROR);
622 results.insert_or_assign("uuidtest02", DBStatus::OK);
623 auto result = kvdbServiceImpl_->ProcessResult(results);
624 std::vector<std::string> devices = result.first;
625 auto it = std::find(devices.begin(), devices.end(), "uuidtest02");
626 ASSERT_NE(it, devices.end());
627 }
628
629 /**
630 * @tc.name: DoSyncBeginTest001
631 * @tc.desc: DoSyncBegin test
632 * @tc.type: FUNC
633 * @tc.author: wangbin
634 */
635 HWTEST_F(KvdbServiceImplTest, DoSyncBeginTest001, TestSize.Level0)
636 {
637 Status status = manager.GetSingleKvStore(create, appId, storeId, kvStore);
638 ASSERT_NE(kvStore, nullptr);
639 ASSERT_EQ(status, Status::SUCCESS);
640 std::vector<std::string> device1{"uuidtest01"};
641 std::vector<std::string> device2;
642 StoreMetaData meta = kvdbServiceImpl_->GetStoreMetaData(appId, storeId);
643 SyncInfo syncInfo;
644 syncInfo.devices = { "device1", "device2" };
645 syncInfo.query = "query";
646 SyncEnd syncEnd = SyncEndCallback;
647 std::map<std::string, DistributedDB::DBStatus> statusMap;
648 statusMap.insert_or_assign("DoSyncBeginTest001", DBStatus::OK);
649 syncEnd(statusMap);
650 status = kvdbServiceImpl_->DoSyncBegin(device2, meta, syncInfo, syncEnd, DBStatus::OK);
651 ASSERT_EQ(status, Status::INVALID_ARGUMENT);
652 status = kvdbServiceImpl_->DoSyncBegin(device1, meta, syncInfo, syncEnd, DBStatus::OK);
653 ASSERT_EQ(status, Status::ERROR);
654 }
655
656 /**
657 * @tc.name: DoCompleteTest001
658 * @tc.desc: DoComplete test
659 * @tc.type: FUNC
660 * @tc.author: wangbin
661 */
662 HWTEST_F(KvdbServiceImplTest, DoCompleteTest001, TestSize.Level0)
663 {
664 Status status = manager.GetSingleKvStore(create, appId, storeId, kvStore);
665 ASSERT_NE(kvStore, nullptr);
666 ASSERT_EQ(status, Status::SUCCESS);
667 StoreMetaData meta = kvdbServiceImpl_->GetStoreMetaData(appId, storeId);
668 SyncInfo syncInfo;
669 syncInfo.devices = { "device1", "device2" };
670 syncInfo.query = "query";
671 syncInfo.seqId = 1; // test
672 RefCount refCount;
673 DBResult dbResult;
674 dbResult.insert_or_assign("DoCompleteTest_1", DBStatus::OK);
675 dbResult.insert_or_assign("DoCompleteTest_1", DBStatus::DB_ERROR);
676 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
677 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
678 status = kvdbServiceImpl_->DoComplete(meta, syncInfo, refCount, dbResult);
679 ASSERT_EQ(status, Status::SUCCESS);
680 syncInfo.seqId = std::numeric_limits<uint64_t>::max();
681 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_NATIVE))
682 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
683 status = kvdbServiceImpl_->DoComplete(meta, syncInfo, refCount, dbResult);
684 ASSERT_EQ(status, Status::SUCCESS);
685 }
686
687 /**
688 * @tc.name: ConvertDbStatusNativeTest001
689 * @tc.desc: ConvertDbStatusNative test
690 * @tc.type: FUNC
691 * @tc.author: wangbin
692 */
693 HWTEST_F(KvdbServiceImplTest, ConvertDbStatusNativeTest001, TestSize.Level0)
694 {
695 auto status = kvdbServiceImpl_->ConvertDbStatusNative(DBStatus::DB_ERROR);
696 ASSERT_EQ(status, Status::DB_ERROR);
697 status = kvdbServiceImpl_->ConvertDbStatusNative(DBStatus::COMM_FAILURE);
698 ASSERT_EQ(status, Status::DEVICE_NOT_ONLINE);
699 DBStatus dbstatus = static_cast<DBStatus>(DBStatus::OK - 1);
700 status = kvdbServiceImpl_->ConvertDbStatusNative(dbstatus);
701 ASSERT_EQ(status, - 1);
702 }
703
704 /**
705 * @tc.name: GetSyncDelayTimeTest001
706 * @tc.desc: GetSyncDelayTime test
707 * @tc.type: FUNC
708 * @tc.author: wangbin
709 */
710 HWTEST_F(KvdbServiceImplTest, GetSyncDelayTimeTest001, TestSize.Level0)
711 {
712 auto status = kvdbServiceImpl_->GetSyncDelayTime(1, storeId);
713 ASSERT_EQ(status, DistributedKv::KvStoreSyncManager::SYNC_MIN_DELAY_MS);
714 status = kvdbServiceImpl_->GetSyncDelayTime(0, storeId);
715 ASSERT_EQ(status, 0);
716 }
717
718 /**
719 * @tc.name: ConvertGeneralErrTest
720 * @tc.desc: ConvertGeneralErr test the return result of input with different values.
721 * @tc.type: FUNC
722 * @tc.author: wangbin
723 */
724 HWTEST_F(KvdbServiceImplTest, ConvertGeneralErrTest, TestSize.Level0)
725 {
726 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_DB_ERROR), Status::DB_ERROR);
727 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_OK), Status::SUCCESS);
728 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_INVALID_ARGS), Status::INVALID_ARGUMENT);
729 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_RECORD_NOT_FOUND), Status::KEY_NOT_FOUND);
730 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_INVALID_VALUE_FIELDS), Status::INVALID_VALUE_FIELDS);
731 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_INVALID_FIELD_TYPE), Status::INVALID_FIELD_TYPE);
732 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_CONSTRAIN_VIOLATION), Status::CONSTRAIN_VIOLATION);
733 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_INVALID_FORMAT), Status::INVALID_FORMAT);
734 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_INVALID_QUERY_FORMAT), Status::INVALID_QUERY_FORMAT);
735 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_INVALID_QUERY_FIELD), Status::INVALID_QUERY_FIELD);
736 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_NOT_SUPPORT), Status::NOT_SUPPORT);
737 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_TIME_OUT), Status::TIME_OUT);
738 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_OVER_MAX_LIMITS), Status::OVER_MAX_LIMITS);
739 EXPECT_EQ(kvdbServiceImpl_->ConvertGeneralErr(GeneralError::E_SECURITY_LEVEL_ERROR), Status::SECURITY_LEVEL_ERROR);
740 }
741
742 /**
743 * @tc.name: DisableCapabilityTest001
744 * @tc.desc: DisableCapability test
745 * @tc.type: FUNC
746 * @tc.author: wangbin
747 */
748 HWTEST_F(KvdbServiceImplTest, DisableCapabilityTest001, TestSize.Level0)
749 {
750 ZLOGI("DisableCapabilityTest001 start");
751 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
752 ASSERT_NE(kvStore, nullptr);
753 ASSERT_EQ(status1, Status::SUCCESS);
754 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_NATIVE))
755 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
756 auto status = kvdbServiceImpl_->DisableCapability(appId, storeId, 0);
757 ZLOGI("DisableCapabilityTest001 status = :%{public}d", status);
758 ASSERT_EQ(status, Status::SUCCESS);
759 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
760 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
761 status = kvdbServiceImpl_->EnableCapability(appId, storeId, 0);
762 ASSERT_EQ(status, Status::ILLEGAL_STATE);
763 }
764
765 /**
766 * @tc.name: SetCapabilityTest001
767 * @tc.desc: SetCapability test
768 * @tc.type: FUNC
769 * @tc.author: wangbin
770 */
771 HWTEST_F(KvdbServiceImplTest, SetCapabilityTest001, TestSize.Level0)
772 {
773 ZLOGI("SetCapabilityTest001 start");
774 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
775 ASSERT_NE(kvStore, nullptr);
776 ASSERT_EQ(status1, Status::SUCCESS);
777 std::vector<std::string> local;
778 std::vector<std::string> remote;
779 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_NATIVE))
780 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
781 auto status = kvdbServiceImpl_->SetCapability(appId, storeId, 0, local, remote);
782 ZLOGI("SetCapabilityTest001 status = :%{public}d", status);
783 ASSERT_EQ(status, Status::SUCCESS);
784 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_)).WillOnce(testing::Return(ATokenTypeEnum::TOKEN_HAP))
785 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_HAP));
786 status = kvdbServiceImpl_->EnableCapability(appId, storeId, 0);
787 ASSERT_EQ(status, Status::ILLEGAL_STATE);
788 }
789
790 /**
791 * @tc.name: AddSubscribeInfoTest001
792 * @tc.desc: AddSubscribeInfo test
793 * @tc.type: FUNC
794 * @tc.author: wangbin
795 */
796 HWTEST_F(KvdbServiceImplTest, AddSubscribeInfoTest001, TestSize.Level0)
797 {
798 ZLOGI("AddSubscribeInfoTest001 start");
799 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
800 ASSERT_NE(kvStore, nullptr);
801 ASSERT_EQ(status1, Status::SUCCESS);
802 SyncInfo syncInfo;
803 EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(testing::_))
804 .WillOnce(testing::Return(ATokenTypeEnum::TOKEN_NATIVE))
805 .WillRepeatedly(testing::Return(ATokenTypeEnum::TOKEN_NATIVE));
806 auto status = kvdbServiceImpl_->AddSubscribeInfo(appId, storeId, 0, syncInfo);
807 ZLOGI("AddSubscribeInfoTest001 status = :%{public}d", status);
808 ASSERT_NE(status, Status::SUCCESS);
809 }
810
811 /**
812 * @tc.name: RmvSubscribeInfoTest001
813 * @tc.desc: RmvSubscribeInfo test
814 * @tc.type: FUNC
815 * @tc.author: wangbin
816 */
817 HWTEST_F(KvdbServiceImplTest, RmvSubscribeInfoTest001, TestSize.Level0)
818 {
819 ZLOGI("RmvSubscribeInfoTest001 start");
820 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
821 ASSERT_NE(kvStore, nullptr);
822 ASSERT_EQ(status1, Status::SUCCESS);
823 SyncInfo syncInfo;
824 auto status = kvdbServiceImpl_->RmvSubscribeInfo(appId, storeId, 0, syncInfo);
825 ZLOGI("RmvSubscribeInfoTest001 status = :%{public}d", status);
826 ASSERT_NE(status, Status::SUCCESS);
827 }
828
829 /**
830 * @tc.name: SubscribeTest001
831 * @tc.desc: Subscribe test
832 * @tc.type: FUNC
833 * @tc.author: wangbin
834 */
835 HWTEST_F(KvdbServiceImplTest, SubscribeTest001, TestSize.Level0)
836 {
837 ZLOGI("SubscribeTest001 start");
838 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
839 ASSERT_NE(kvStore, nullptr);
840 ASSERT_EQ(status1, Status::SUCCESS);
841 sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
842 auto status = kvdbServiceImpl_->Subscribe(appId, storeId, 0, observer);
843 ZLOGI("SubscribeTest001 status = :%{public}d", status);
844 ASSERT_EQ(status, Status::INVALID_ARGUMENT);
845 }
846
847 /**
848 * @tc.name: UnsubscribeTest001
849 * @tc.desc: Unsubscribe test
850 * @tc.type: FUNC
851 * @tc.author: wangbin
852 */
853 HWTEST_F(KvdbServiceImplTest, UnsubscribeTest001, TestSize.Level0)
854 {
855 ZLOGI("UnsubscribeTest001 start");
856 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
857 ASSERT_NE(kvStore, nullptr);
858 ASSERT_EQ(status1, Status::SUCCESS);
859 sptr<DistributedKv::IKVDBNotifier> notifier;
860 DistributedKv::KVDBServiceImpl::SyncAgent syncAgent;
861 syncAgent.pid_ = 1; // test
862 syncAgent.switchesObserverCount_ = 1; // test
863 syncAgent.appId_ = { "ohos.OnAsyncCompleteTest001.kvdb" };
864 syncAgent.notifier_ = notifier;
865 auto tokenId = IPCSkeleton::GetCallingTokenID();
866 kvdbServiceImpl_->syncAgents_.Insert(tokenId, syncAgent);
867 sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
868 auto status = kvdbServiceImpl_->Unsubscribe(appId, storeId, 0, observer);
869 ZLOGI("UnsubscribeTest001 status = :%{public}d", status);
870 ASSERT_EQ(status, Status::SUCCESS);
871 }
872
873 /**
874 * @tc.name: GetBackupPasswordTest001
875 * @tc.desc: GetBackupPassword test
876 * @tc.type: FUNC
877 * @tc.author: wangbin
878 */
879 HWTEST_F(KvdbServiceImplTest, GetBackupPasswordTest001, TestSize.Level0)
880 {
881 auto status = manager.GetSingleKvStore(create, appId, storeId, kvStore);
882 ASSERT_NE(kvStore, nullptr);
883 ASSERT_EQ(status, Status::SUCCESS);
884 std::vector<std::vector<uint8_t>> password;
885 status = kvdbServiceImpl_->GetBackupPassword
886 (appId, storeId, 0, password, DistributedKv::KVDBService::PasswordType::BACKUP_SECRET_KEY);
887 ASSERT_EQ(status, Status::ERROR);
888 status = kvdbServiceImpl_->GetBackupPassword
889 (appId, storeId, 0, password, DistributedKv::KVDBService::PasswordType::SECRET_KEY);
890 ASSERT_EQ(status, Status::ERROR);
891 status = kvdbServiceImpl_->GetBackupPassword
892 (appId, storeId, 0, password, DistributedKv::KVDBService::PasswordType::BUTTON);
893 ASSERT_EQ(status, Status::ERROR);
894 }
895
896 /**
897 * @tc.name: BeforeCreateTest001
898 * @tc.desc: BeforeCreate test
899 * @tc.type: FUNC
900 * @tc.author: wangbin
901 */
902 HWTEST_F(KvdbServiceImplTest, BeforeCreateTest001, TestSize.Level0)
903 {
904 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
905 ASSERT_NE(kvStore, nullptr);
906 ASSERT_EQ(status1, Status::SUCCESS);
907 Options creates;
908 creates.createIfMissing = true;
909 creates.encrypt = false;
910 creates.securityLevel = OHOS::DistributedKv::S1;
911 creates.autoSync = true;
912 creates.kvStoreType = OHOS::DistributedKv::SINGLE_VERSION;
913 creates.area = OHOS::DistributedKv::EL1;
914 creates.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
915 creates.cloudConfig.enableCloud = true;
916 kvdbServiceImpl_->executors_ = std::make_shared<ExecutorPool>(1, 1);
917 EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
918 .WillOnce(testing::Return(false)).WillRepeatedly(testing::Return(false));
919 auto status = kvdbServiceImpl_->BeforeCreate(appId, storeId, creates);
920 ASSERT_NE(status, Status::STORE_META_CHANGED);
921 kvdbServiceImpl_->executors_ = nullptr;
922 ASSERT_EQ(status, Status::SUCCESS);
923 }
924
925 /**
926 * @tc.name: AfterCreateTest001
927 * @tc.desc: AfterCreate test
928 * @tc.type: FUNC
929 * @tc.author: wangbin
930 */
931 HWTEST_F(KvdbServiceImplTest, AfterCreateTest001, TestSize.Level0)
932 {
933 ZLOGI("AfterCreateTest001 start");
934 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
935 ASSERT_NE(kvStore, nullptr);
936 ASSERT_EQ(status1, Status::SUCCESS);
937 std::vector<uint8_t> password;
938 auto status = kvdbServiceImpl_->AfterCreate(appId, storeId, create, password);
939 ZLOGI("AfterCreateTest001 status = :%{public}d", status);
940 ASSERT_EQ(status, Status::SUCCESS);
941 AppId appIds;
942 appIds.appId = "";
943 status = kvdbServiceImpl_->AfterCreate(appIds, storeId, create, password);
944 ASSERT_EQ(status, Status::INVALID_ARGUMENT);
945 StoreId storeIds;
946 storeIds.storeId = "";
947 status = kvdbServiceImpl_->AfterCreate(appId, storeIds, create, password);
948 ASSERT_EQ(status, Status::INVALID_ARGUMENT);
949 status = kvdbServiceImpl_->AfterCreate(appIds, storeIds, create, password);
950 ASSERT_EQ(status, Status::INVALID_ARGUMENT);
951 }
952
953 /**
954 * @tc.name: OnAppExitTest001
955 * @tc.desc: OnAppExit test
956 * @tc.type: FUNC
957 * @tc.author: wangbin
958 */
959 HWTEST_F(KvdbServiceImplTest, OnAppExitTest001, TestSize.Level0)
960 {
961 ZLOGI("OnAppExitTest001 start");
962 Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
963 ASSERT_NE(kvStore, nullptr);
964 ASSERT_EQ(status1, Status::SUCCESS);
965 pid_t uid = 1;
966 pid_t pid = 2;
967 const char **perms = new const char *[2];
968 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
969 perms[1] = "ohos.permission.ACCESS_SERVICE_DM";
970 TokenInfoParams infoInstance = {
971 .dcapsNum = 0,
972 .permsNum = 2,
973 .aclsNum = 0,
974 .dcaps = nullptr,
975 .perms = perms,
976 .acls = nullptr,
977 .processName = "distributed_data_test",
978 .aplStr = "system_basic",
979 };
980 uint32_t tokenId = GetAccessTokenId(&infoInstance);
981 auto status = kvdbServiceImpl_->OnAppExit(uid, pid, tokenId, appId);
982 ZLOGI("OnAppExitTest001 status = :%{public}d", status);
983 ASSERT_EQ(status, Status::SUCCESS);
984 }
985
986 /**
987 * @tc.name: CompareTripleIdentifierTest001
988 * @tc.desc: CompareTripleIdentifier test
989 * @tc.type: FUNC
990 * @tc.author: wangbin
991 */
992 HWTEST_F(KvdbServiceImplTest, CompareTripleIdentifierTest001, TestSize.Level0)
993 {
994 std::string accountId = "accountIdTest";
995 std::string identifier = "identifierTest";
996 StoreMetaData meta = kvdbServiceImpl_->GetStoreMetaData(appId, storeId);
997 auto status = kvdbServiceImpl_->CompareTripleIdentifier(accountId, identifier, meta);
998 ASSERT_EQ(status, false);
999 }
1000
1001 /**
1002 * @tc.name: OnUserChangeTest001
1003 * @tc.desc: OnUserChange test
1004 * @tc.type: FUNC
1005 * @tc.author: wangbin
1006 */
1007 HWTEST_F(KvdbServiceImplTest, OnUserChangeTest001, TestSize.Level0)
1008 {
1009 ZLOGI("OnUserChangeTest001 start");
1010 uint32_t code = 1;
1011 std::string user = "OH_USER_test";
1012 std::string account = "OH_ACCOUNT_test";
1013 auto status = kvdbServiceImpl_->OnUserChange(code, user, account);
1014 ZLOGI("OnUserChangeTest001 status = :%{public}d", status);
1015 ASSERT_EQ(status, Status::SUCCESS);
1016 }
1017
1018 /**
1019 * @tc.name: OnReadyTest001
1020 * @tc.desc: OnReady test
1021 * @tc.type: FUNC
1022 * @tc.author: wangbin
1023 */
1024 HWTEST_F(KvdbServiceImplTest, OnReadyTest001, TestSize.Level0)
1025 {
1026 ZLOGI("OnReadyTest001 start");
1027 std::string device = "OH_device_test";
1028 auto status = kvdbServiceImpl_->OnReady(device);
1029 ZLOGI("OnReadyTest001 status = :%{public}d", status);
1030 ASSERT_EQ(status, Status::SUCCESS);
1031 status = kvdbServiceImpl_->OnSessionReady(device);
1032 ASSERT_EQ(status, Status::SUCCESS);
1033 }
1034
1035 /**
1036 * @tc.name: ResolveAutoLaunch
1037 * @tc.desc: ResolveAutoLaunch function test.
1038 * @tc.type: FUNC
1039 * @tc.author: SQL
1040 */
1041 HWTEST_F(KvdbServiceImplTest, ResolveAutoLaunch, TestSize.Level0)
1042 {
1043 StoreId id1;
1044 id1.storeId = "id1";
1045 Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
1046 EXPECT_NE(kvStore, nullptr);
1047 EXPECT_EQ(status, Status::SUCCESS);
1048 std::string identifier = "identifier";
1049 DistributedKv::KVDBServiceImpl::DBLaunchParam launchParam;
1050 auto result = kvdbServiceImpl_->ResolveAutoLaunch(identifier, launchParam);
1051 EXPECT_EQ(result, Status::STORE_NOT_FOUND);
1052 std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(1, 0);
1053 Bootstrap::GetInstance().LoadDirectory();
1054 Bootstrap::GetInstance().LoadCheckers();
1055 DistributedKv::KvStoreMetaManager::GetInstance().BindExecutor(executors);
1056 DistributedKv::KvStoreMetaManager::GetInstance().InitMetaParameter();
1057 DistributedKv::KvStoreMetaManager::GetInstance().InitMetaListener();
1058 result = kvdbServiceImpl_->ResolveAutoLaunch(identifier, launchParam);
1059 EXPECT_EQ(result, Status::SUCCESS);
1060 }
1061
1062 /**
1063 * @tc.name: IsRemoteChange
1064 * @tc.desc: IsRemoteChange function test.
1065 * @tc.type: FUNC
1066 * @tc.author: wangbin
1067 */
1068 HWTEST_F(KvdbServiceImplTest, IsRemoteChangeTest, TestSize.Level0)
1069 {
1070 StoreMetaData meta = kvdbServiceImpl_->GetStoreMetaData(appId, storeId);
1071 std::string devices= "IsRemoteChangeTest";
1072 auto changes = kvdbServiceImpl_->IsRemoteChange(meta, devices);
1073 EXPECT_EQ(changes, true);
1074 }
1075
1076 /**
1077 * @tc.name: PutSwitch
1078 * @tc.desc: PutSwitch function test.
1079 * @tc.type: FUNC
1080 * @tc.author: SQL
1081 */
1082 HWTEST_F(KvdbServiceImplTest, PutSwitch, TestSize.Level0)
1083 {
1084 StoreId id1;
1085 id1.storeId = "id1";
1086 Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
1087 ASSERT_NE(kvStore, nullptr);
1088 ASSERT_EQ(status, Status::SUCCESS);
1089 DistributedKv::SwitchData switchData;
1090 status = kvdbServiceImpl_->PutSwitch(appId, switchData);
1091 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1092 switchData.value = DeviceMatrix::INVALID_VALUE;
1093 switchData.length = DeviceMatrix::INVALID_LEVEL;
1094 status = kvdbServiceImpl_->PutSwitch(appId, switchData);
1095 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1096 switchData.value = DeviceMatrix::INVALID_MASK;
1097 switchData.length = DeviceMatrix::INVALID_LENGTH;
1098 status = kvdbServiceImpl_->PutSwitch(appId, switchData);
1099 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1100 switchData.value = DeviceMatrix::INVALID_VALUE;
1101 switchData.length = DeviceMatrix::INVALID_LENGTH;
1102 status = kvdbServiceImpl_->PutSwitch(appId, switchData);
1103 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1104 switchData.value = DeviceMatrix::INVALID_MASK;
1105 switchData.length = DeviceMatrix::INVALID_LEVEL;
1106 status = kvdbServiceImpl_->PutSwitch(appId, switchData);
1107 EXPECT_EQ(status, Status::SUCCESS);
1108 std::string networkId = "networkId";
1109 status = kvdbServiceImpl_->GetSwitch(appId, networkId, switchData);
1110 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1111 }
1112
1113 /**
1114 * @tc.name: DoCloudSync
1115 * @tc.desc: DoCloudSync error function test.
1116 * @tc.type: FUNC
1117 * @tc.author: SQL
1118 */
1119 HWTEST_F(KvdbServiceImplTest, DoCloudSync, TestSize.Level0)
1120 {
1121 StoreId id1;
1122 id1.storeId = "id1";
1123 Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
1124 ASSERT_NE(kvStore, nullptr);
1125 ASSERT_EQ(status, Status::SUCCESS);
1126 StoreMetaData metaData;
1127 SyncInfo syncInfo;
1128 status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
1129 EXPECT_EQ(status, Status::NOT_SUPPORT);
1130 syncInfo.devices = { "device1", "device2" };
1131 syncInfo.query = "query";
1132 metaData.enableCloud = true;
1133 status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
1134 EXPECT_EQ(status, Status::CLOUD_DISABLED);
1135 }
1136
1137 /**
1138 * @tc.name: ConvertDbStatus
1139 * @tc.desc: ConvertDbStatus test the return result of input with different values.
1140 * @tc.type: FUNC
1141 * @tc.author: SQL
1142 */
1143 HWTEST_F(KvdbServiceImplTest, ConvertDbStatus, TestSize.Level0)
1144 {
1145 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::BUSY), Status::DB_ERROR);
1146 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::DB_ERROR), Status::DB_ERROR);
1147 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::OK), Status::SUCCESS);
1148 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_ARGS), Status::INVALID_ARGUMENT);
1149 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::NOT_FOUND), Status::KEY_NOT_FOUND);
1150 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_VALUE_FIELDS), Status::INVALID_VALUE_FIELDS);
1151 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_FIELD_TYPE), Status::INVALID_FIELD_TYPE);
1152 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::CONSTRAIN_VIOLATION), Status::CONSTRAIN_VIOLATION);
1153 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_FORMAT), Status::INVALID_FORMAT);
1154 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_QUERY_FORMAT), Status::INVALID_QUERY_FORMAT);
1155 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_QUERY_FIELD), Status::INVALID_QUERY_FIELD);
1156 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::NOT_SUPPORT), Status::NOT_SUPPORT);
1157 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::TIME_OUT), Status::TIME_OUT);
1158 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::OVER_MAX_LIMITS), Status::OVER_MAX_LIMITS);
1159 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::EKEYREVOKED_ERROR), Status::SECURITY_LEVEL_ERROR);
1160 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::SECURITY_OPTION_CHECK_ERROR), Status::SECURITY_LEVEL_ERROR);
1161 EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::SCHEMA_VIOLATE_VALUE), Status::ERROR);
1162 }
1163
1164 /**
1165 * @tc.name: ConvertDBMode
1166 * @tc.desc: ConvertDBMode test the return result of input with different values.
1167 * @tc.type: FUNC
1168 * @tc.author: SQL
1169 */
1170 HWTEST_F(KvdbServiceImplTest, ConvertDBMode, TestSize.Level0)
1171 {
1172 auto status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PUSH);
1173 EXPECT_EQ(status, DBMode::SYNC_MODE_PUSH_ONLY);
1174 status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PULL);
1175 EXPECT_EQ(status, DBMode::SYNC_MODE_PULL_ONLY);
1176 status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PUSH_PULL);
1177 EXPECT_EQ(status, DBMode::SYNC_MODE_PUSH_PULL);
1178 }
1179
1180 /**
1181 * @tc.name: ConvertGeneralSyncMode
1182 * @tc.desc: ConvertGeneralSyncMode test the return result of input with different values.
1183 * @tc.type: FUNC
1184 * @tc.author: SQL
1185 */
1186 HWTEST_F(KvdbServiceImplTest, ConvertGeneralSyncMode, TestSize.Level0)
1187 {
1188 auto status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_SUBSCRIBE);
1189 EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_SUBSCRIBE_REMOTE);
1190 status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_UNSUBSCRIBE);
1191 EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_UNSUBSCRIBE_REMOTE);
1192 status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_SYNC);
1193 EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PUSH);
1194 status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PULL, SyncAction::ACTION_SYNC);
1195 EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PULL);
1196 status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH_PULL, SyncAction::ACTION_SYNC);
1197 EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PULL_PUSH);
1198 auto action = static_cast<SyncAction>(SyncAction::ACTION_UNSUBSCRIBE + 1);
1199 status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, action);
1200 EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_END);
1201 }
1202
1203 /**
1204 * @tc.name: ConvertType
1205 * @tc.desc: ConvertType test the return result of input with different values.
1206 * @tc.type: FUNC
1207 * @tc.author: SQL
1208 */
1209 HWTEST_F(KvdbServiceImplTest, ConvertType, TestSize.Level0)
1210 {
1211 auto status = kvdbServiceImpl_->ConvertType(SyncMode::PUSH);
1212 EXPECT_EQ(status, ChangeType::CHANGE_LOCAL);
1213 status = kvdbServiceImpl_->ConvertType(SyncMode::PULL);
1214 EXPECT_EQ(status, ChangeType::CHANGE_REMOTE);
1215 status = kvdbServiceImpl_->ConvertType(SyncMode::PUSH_PULL);
1216 EXPECT_EQ(status, ChangeType::CHANGE_ALL);
1217 auto action = static_cast<SyncMode>(SyncMode::PUSH_PULL + 1);
1218 status = kvdbServiceImpl_->ConvertType(action);
1219 EXPECT_EQ(status, ChangeType::CHANGE_ALL);
1220 }
1221
1222 /**
1223 * @tc.name: ConvertAction
1224 * @tc.desc: ConvertAction test the return result of input with different values.
1225 * @tc.type: FUNC
1226 * @tc.author: SQL
1227 */
1228 HWTEST_F(KvdbServiceImplTest, ConvertAction, TestSize.Level0)
1229 {
1230 auto status = kvdbServiceImpl_->ConvertAction(Action::INSERT);
1231 EXPECT_EQ(status, SwitchState::INSERT);
1232 status = kvdbServiceImpl_->ConvertAction(Action::UPDATE);
1233 EXPECT_EQ(status, SwitchState::UPDATE);
1234 status = kvdbServiceImpl_->ConvertAction(Action::DELETE);
1235 EXPECT_EQ(status, SwitchState::DELETE);
1236 auto action = static_cast<Action>(Action::DELETE + 1);
1237 status = kvdbServiceImpl_->ConvertAction(action);
1238 EXPECT_EQ(status, SwitchState::INSERT);
1239 }
1240
1241 /**
1242 * @tc.name: GetSyncMode
1243 * @tc.desc: GetSyncMode test the return result of input with different values.
1244 * @tc.type: FUNC
1245 * @tc.author: SQL
1246 */
1247 HWTEST_F(KvdbServiceImplTest, GetSyncMode, TestSize.Level0)
1248 {
1249 auto status = kvdbServiceImpl_->GetSyncMode(true, true);
1250 EXPECT_EQ(status, SyncMode::PUSH_PULL);
1251 status = kvdbServiceImpl_->GetSyncMode(true, false);
1252 EXPECT_EQ(status, SyncMode::PUSH);
1253 status = kvdbServiceImpl_->GetSyncMode(false, true);
1254 EXPECT_EQ(status, SyncMode::PULL);
1255 status = kvdbServiceImpl_->GetSyncMode(false, false);
1256 EXPECT_EQ(status, SyncMode::PUSH_PULL);
1257 }
1258
1259 /**
1260 * @tc.name: DoCloudSync02
1261 * @tc.desc: DoCloudSync02 function test.
1262 * @tc.type: FUNC
1263 * @tc.author:
1264 */
1265 HWTEST_F(KvdbServiceImplTest, DoCloudSync02, TestSize.Level0)
1266 {
1267 delegate_.isNetworkAvailable_ = false;
1268 auto cloudServerMock = new CloudServerMock();
1269 CloudServer::RegisterCloudInstance(cloudServerMock);
1270 StoreMetaData metaData;
1271 metaData.enableCloud = true;
1272 SyncInfo syncInfo;
1273 auto status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
1274 EXPECT_EQ(status, OHOS::DistributedKv::Status::NETWORK_ERROR);
1275 }
1276 } // namespace DistributedDataTest
1277 } // namespace OHOS::Test