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 <gtest/gtest.h>
17 #include "log_print.h"
18 #include "accesstoken_kit.h"
19 #include "bootstrap.h"
20 #include "checker/checker_manager.h"
21 #include "distributed_kv_data_manager.h"
22 #include "device_manager_adapter.h"
23 #include "ipc_skeleton.h"
24 #include "nativetoken_kit.h"
25 #include "kvdb_service_impl.h"
26 #include "kvdb_service_stub.h"
27 #include "kvstore_death_recipient.h"
28 #include "kvstore_meta_manager.h"
29 #include "utils/constant.h"
30 #include "utils/anonymous.h"
31 #include "token_setproc.h"
32 #include "types.h"
33 #include <vector>
34 
35 using namespace testing::ext;
36 using namespace OHOS::DistributedData;
37 using namespace OHOS::Security::AccessToken;
38 using Action = OHOS::DistributedData::MetaDataManager::Action;
39 using AppId = OHOS::DistributedKv::AppId;
40 using ChangeType = OHOS::DistributedData::DeviceMatrix::ChangeType;
41 using DistributedKvDataManager = OHOS::DistributedKv::DistributedKvDataManager;
42 using DBStatus = DistributedDB::DBStatus;
43 using DBMode = DistributedDB::SyncMode;
44 using Options = OHOS::DistributedKv::Options;
45 using Status = OHOS::DistributedKv::Status;
46 using SingleKvStore = OHOS::DistributedKv::SingleKvStore;
47 using StoreId = OHOS::DistributedKv::StoreId;
48 using SyncInfo = OHOS::DistributedKv::KVDBService::SyncInfo;
49 using SyncMode = OHOS::DistributedKv::SyncMode;
50 using SyncAction = OHOS::DistributedKv::KVDBServiceImpl::SyncAction;
51 using SwitchState = OHOS::DistributedKv::SwitchState;
52 using UserId = OHOS::DistributedKv::UserId;
53 static OHOS::DistributedKv::StoreId storeId = { "kvdb_test_storeid" };
54 static OHOS::DistributedKv::AppId appId = { "ohos.test.kvdb" };
55 
56 namespace OHOS::Test {
57 namespace DistributedDataTest {
58 class KvdbServiceImplTest : public testing::Test {
59 public:
60     static constexpr size_t NUM_MIN = 5;
61     static constexpr size_t NUM_MAX = 12;
62     static DistributedKvDataManager manager;
63     static Options create;
64     static UserId userId;
65 
66     std::shared_ptr<SingleKvStore> kvStore;
67 
68     static AppId appId;
69     static StoreId storeId64;
70     static StoreId storeId65;
71 
72     static void SetUpTestCase(void);
73     static void TearDownTestCase(void);
74     static void RemoveAllStore(OHOS::DistributedKv::DistributedKvDataManager &manager);
75     void SetUp();
76     void TearDown();
77 
78     KvdbServiceImplTest();
79 protected:
80     std::shared_ptr<DistributedKv::KVDBServiceImpl> kvdbServiceImpl_;
81 };
82 
83 OHOS::DistributedKv::DistributedKvDataManager KvdbServiceImplTest::manager;
84 Options KvdbServiceImplTest::create;
85 UserId KvdbServiceImplTest::userId;
86 
87 AppId KvdbServiceImplTest::appId;
88 StoreId KvdbServiceImplTest::storeId64;
89 StoreId KvdbServiceImplTest::storeId65;
90 
RemoveAllStore(DistributedKvDataManager & manager)91 void KvdbServiceImplTest::RemoveAllStore(DistributedKvDataManager &manager)
92 {
93     manager.CloseAllKvStore(appId);
94     manager.DeleteAllKvStore(appId, create.baseDir);
95 }
96 
SetUpTestCase(void)97 void KvdbServiceImplTest::SetUpTestCase(void)
98 {
99     auto executors = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
100     manager.SetExecutors(executors);
101     userId.userId = "kvdbserviceimpltest1";
102     appId.appId = "ohos.kvdbserviceimpl.test";
103     create.createIfMissing = true;
104     create.encrypt = false;
105     create.securityLevel = OHOS::DistributedKv::S1;
106     create.autoSync = true;
107     create.kvStoreType = OHOS::DistributedKv::SINGLE_VERSION;
108     create.area = OHOS::DistributedKv::EL1;
109     create.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
110     mkdir(create.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
111 
112     storeId64.storeId = "a000000000b000000000c000000000d000000000e000000000f000000000g000";
113     storeId65.storeId = "a000000000b000000000c000000000d000000000e000000000f000000000g000"
114                         "a000000000b000000000c000000000d000000000e000000000f000000000g0000";
115     RemoveAllStore(manager);
116 }
117 
TearDownTestCase()118 void KvdbServiceImplTest::TearDownTestCase()
119 {
120     RemoveAllStore(manager);
121     (void)remove((create.baseDir + "/kvdb").c_str());
122     (void)remove(create.baseDir.c_str());
123 }
124 
SetUp(void)125 void KvdbServiceImplTest::SetUp(void)
126 {
127     kvdbServiceImpl_ = std::make_shared<DistributedKv::KVDBServiceImpl>();
128 }
129 
TearDown(void)130 void KvdbServiceImplTest::TearDown(void)
131 {
132     RemoveAllStore(manager);
133 }
134 
KvdbServiceImplTest(void)135 KvdbServiceImplTest::KvdbServiceImplTest(void)
136 {}
137 
138 /**
139 * @tc.name: KvdbServiceImpl001
140 * @tc.desc: KvdbServiceImplTest function test.
141 * @tc.type: FUNC
142 * @tc.author: SQL
143 */
144 HWTEST_F(KvdbServiceImplTest, KvdbServiceImpl001, TestSize.Level0)
145 {
146     std::string device = "OH_device_test";
147     StoreId id1;
148     id1.storeId = "id1";
149     Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
150     EXPECT_NE(kvStore, nullptr);
151     EXPECT_EQ(status, Status::SUCCESS);
152     int32_t result = kvdbServiceImpl_->OnInitialize();
153     EXPECT_EQ(result, Status::SUCCESS);
154     FeatureSystem::Feature::BindInfo bindInfo;
155     result = kvdbServiceImpl_->OnBind(bindInfo);
156     EXPECT_EQ(result, Status::SUCCESS);
157     result = kvdbServiceImpl_->Online(device);
158     EXPECT_EQ(result, Status::SUCCESS);
159     status = kvdbServiceImpl_->SubscribeSwitchData(appId);
160     EXPECT_EQ(status, Status::SUCCESS);
161     SyncInfo syncInfo;
162     status = kvdbServiceImpl_->CloudSync(appId, id1, syncInfo);
163     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
164 
165     DistributedKv::StoreConfig storeConfig;
166     status = kvdbServiceImpl_->SetConfig(appId, id1, storeConfig);
167     EXPECT_EQ(status, Status::SUCCESS);
168     status = kvdbServiceImpl_->NotifyDataChange(appId, id1, 0);
169     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
170 
171     status = kvdbServiceImpl_->UnsubscribeSwitchData(appId);
172     EXPECT_EQ(status, Status::SUCCESS);
173     status = kvdbServiceImpl_->Close(appId, id1);
174     EXPECT_EQ(status, Status::SUCCESS);
175 }
176 
177 /**
178 * @tc.name: GetStoreIdsTest001
179 * @tc.desc: GetStoreIds
180 * @tc.type: FUNC
181 * @tc.author: wangbin
182 */
183 HWTEST_F(KvdbServiceImplTest, GetStoreIdsTest001, TestSize.Level0)
184 {
185     ZLOGI("GetStoreIdsTest001 start");
186     StoreId id1;
187     id1.storeId = "id1";
188     StoreId id2;
189     id2.storeId = "id2";
190     StoreId id3;
191     id3.storeId = "id3";
192     Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
193     ASSERT_NE(kvStore, nullptr);
194     ASSERT_EQ(status, Status::SUCCESS);
195     status = manager.GetSingleKvStore(create, appId, id2, kvStore);
196     ASSERT_NE(kvStore, nullptr);
197     ASSERT_EQ(status, Status::SUCCESS);
198     status = manager.GetSingleKvStore(create, appId, id3, kvStore);
199     ASSERT_NE(kvStore, nullptr);
200     ASSERT_EQ(status, Status::SUCCESS);
201     std::vector<StoreId> storeIds;
202     status = kvdbServiceImpl_->GetStoreIds(appId, storeIds);
203     ASSERT_EQ(status, Status::SUCCESS);
204 }
205 
206 /**
207 * @tc.name: GetStoreIdsTest002
208 * @tc.desc: GetStoreIds
209 * @tc.type: FUNC
210 * @tc.author: wangbin
211 */
212 HWTEST_F(KvdbServiceImplTest, GetStoreIdsTest002, TestSize.Level0)
213 {
214     ZLOGI("GetStoreIdsTest002 start");
215     std::vector<StoreId> storeIds;
216     AppId appId01;
217     auto status = kvdbServiceImpl_->GetStoreIds(appId01, storeIds);
218     ZLOGI("GetStoreIdsTest002 status = :%{public}d", status);
219     ASSERT_EQ(status, Status::SUCCESS);
220 }
221 
222 /**
223 * @tc.name: DeleteTest001
224 * @tc.desc: GetStoreIds
225 * @tc.type: FUNC
226 * @tc.author: wangbin
227 */
228 HWTEST_F(KvdbServiceImplTest, DeleteTest001, TestSize.Level0)
229 {
230     ZLOGI("DeleteTest001 start");
231     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
232     ASSERT_NE(kvStore, nullptr);
233     ASSERT_EQ(status1, Status::SUCCESS);
234     auto status = kvdbServiceImpl_->Delete(appId, storeId);
235     ZLOGI("DeleteTest001 status = :%{public}d", status);
236     ASSERT_EQ(status, Status::SUCCESS);
237 }
238 
239 /**
240 * @tc.name: DeleteTest002
241 * @tc.desc: GetStoreIds
242 * @tc.type: FUNC
243 * @tc.author: wangbin
244 */
245 HWTEST_F(KvdbServiceImplTest, DeleteTest002, TestSize.Level0)
246 {
247     ZLOGI("DeleteTest002 start");
248     AppId appId01 = { "ohos.kvdbserviceimpl.test01" };
249     StoreId storeId01 = { "meta_test_storeid" };
250     auto status = kvdbServiceImpl_->Delete(appId01, storeId01);
251     ZLOGI("DeleteTest002 status = :%{public}d", status);
252     ASSERT_EQ(status, Status::SUCCESS);
253 }
254 
255 /**
256 * @tc.name: syncTest001
257 * @tc.desc: GetStoreIds
258 * @tc.type: FUNC
259 * @tc.author: wangbin
260 */
261 HWTEST_F(KvdbServiceImplTest, syncTest001, TestSize.Level0)
262 {
263     ZLOGI("syncTest001 start");
264     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
265     ASSERT_NE(kvStore, nullptr);
266     ASSERT_EQ(status1, Status::SUCCESS);
267     SyncInfo syncInfo;
268     auto status = kvdbServiceImpl_->Sync(appId, storeId, syncInfo);
269     ZLOGI("syncTest001 status = :%{public}d", status);
270     ASSERT_NE(status, Status::SUCCESS);
271 }
272 
273 /**
274 * @tc.name: RegisterSyncCallbackTest001
275 * @tc.desc: GetStoreIds
276 * @tc.type: FUNC
277 * @tc.author: wangbin
278 */
279 HWTEST_F(KvdbServiceImplTest, RegisterSyncCallbackTest001, TestSize.Level0)
280 {
281     ZLOGI("RegisterSyncCallbackTest001 start");
282     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
283     ASSERT_NE(kvStore, nullptr);
284     ASSERT_EQ(status1, Status::SUCCESS);
285     sptr<OHOS::DistributedKv::IKVDBNotifier> notifier;
286     auto status = kvdbServiceImpl_->RegServiceNotifier(appId, notifier);
287     ZLOGI("RegisterSyncCallbackTest001 status = :%{public}d", status);
288     ASSERT_EQ(status, Status::SUCCESS);
289 }
290 
291 /**
292 * @tc.name: UnregisterSyncCallbackTest001
293 * @tc.desc: GetStoreIds
294 * @tc.type: FUNC
295 * @tc.author: wangbin
296 */
297 HWTEST_F(KvdbServiceImplTest, UnregisterSyncCallbackTest001, TestSize.Level0)
298 {
299     ZLOGI("UnregisterSyncCallbackTest001 start");
300     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
301     ASSERT_NE(kvStore, nullptr);
302     ASSERT_EQ(status1, Status::SUCCESS);
303     auto status = kvdbServiceImpl_->UnregServiceNotifier(appId);
304     ZLOGI("UnregisterSyncCallbackTest001 status = :%{public}d", status);
305     ASSERT_EQ(status, Status::SUCCESS);
306 }
307 
308 /**
309 * @tc.name: SetSyncParamTest001
310 * @tc.desc: GetStoreIds
311 * @tc.type: FUNC
312 * @tc.author: wangbin
313 */
314 HWTEST_F(KvdbServiceImplTest, SetSyncParamTest001, TestSize.Level0)
315 {
316     ZLOGI("SetSyncParamTest001 start");
317     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
318     ASSERT_NE(kvStore, nullptr);
319     ASSERT_EQ(status1, Status::SUCCESS);
320     OHOS::DistributedKv::KvSyncParam const syncparam;
321     auto status = kvdbServiceImpl_->SetSyncParam(appId, storeId, syncparam);
322     ZLOGI("SetSyncParamTest001 status = :%{public}d", status);
323     ASSERT_EQ(status, Status::SUCCESS);
324 }
325 
326 /**
327 * @tc.name: GetSyncParamTest001
328 * @tc.desc: GetStoreIds
329 * @tc.type: FUNC
330 * @tc.author: wangbin
331 */
332 HWTEST_F(KvdbServiceImplTest, GetSyncParamTest001, TestSize.Level0)
333 {
334     ZLOGI("GetSyncParamTest001 start");
335     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
336     ASSERT_NE(kvStore, nullptr);
337     ASSERT_EQ(status1, Status::SUCCESS);
338     OHOS::DistributedKv::KvSyncParam syncparam;
339     auto status = kvdbServiceImpl_->GetSyncParam(appId, storeId, syncparam);
340     ZLOGI("GetSyncParamTest001 status = :%{public}d", status);
341     ASSERT_EQ(status, Status::SUCCESS);
342 }
343 
344 /**
345 * @tc.name: EnableCapabilityTest001
346 * @tc.desc: GetStoreIds
347 * @tc.type: FUNC
348 * @tc.author: wangbin
349 */
350 HWTEST_F(KvdbServiceImplTest, EnableCapabilityTest001, TestSize.Level0)
351 {
352     ZLOGI("EnableCapabilityTest001 start");
353     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
354     ASSERT_NE(kvStore, nullptr);
355     ASSERT_EQ(status1, Status::SUCCESS);
356     auto status = kvdbServiceImpl_->EnableCapability(appId, storeId);
357     ZLOGI("EnableCapabilityTest001 status = :%{public}d", status);
358     ASSERT_EQ(status, Status::SUCCESS);
359 }
360 
361 /**
362 * @tc.name: DisableCapabilityTest001
363 * @tc.desc: GetStoreIds
364 * @tc.type: FUNC
365 * @tc.author: wangbin
366 */
367 HWTEST_F(KvdbServiceImplTest, DisableCapabilityTest001, TestSize.Level0)
368 {
369     ZLOGI("DisableCapabilityTest001 start");
370     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
371     ASSERT_NE(kvStore, nullptr);
372     ASSERT_EQ(status1, Status::SUCCESS);
373     auto status = kvdbServiceImpl_->DisableCapability(appId, storeId);
374     ZLOGI("DisableCapabilityTest001 status = :%{public}d", status);
375     ASSERT_EQ(status, Status::SUCCESS);
376 }
377 
378 /**
379 * @tc.name: SetCapabilityTest001
380 * @tc.desc: GetStoreIds
381 * @tc.type: FUNC
382 * @tc.author: wangbin
383 */
384 HWTEST_F(KvdbServiceImplTest, SetCapabilityTest001, TestSize.Level0)
385 {
386     ZLOGI("SetCapabilityTest001 start");
387     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
388     ASSERT_NE(kvStore, nullptr);
389     ASSERT_EQ(status1, Status::SUCCESS);
390     std::vector<std::string> local;
391     std::vector<std::string> remote;
392     auto status = kvdbServiceImpl_->SetCapability(appId, storeId, local, remote);
393     ZLOGI("SetCapabilityTest001 status = :%{public}d", status);
394     ASSERT_EQ(status, Status::SUCCESS);
395 }
396 
397 /**
398 * @tc.name: AddSubscribeInfoTest001
399 * @tc.desc: GetStoreIds
400 * @tc.type: FUNC
401 * @tc.author: wangbin
402 */
403 HWTEST_F(KvdbServiceImplTest, AddSubscribeInfoTest001, TestSize.Level0)
404 {
405     ZLOGI("AddSubscribeInfoTest001 start");
406     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
407     ASSERT_NE(kvStore, nullptr);
408     ASSERT_EQ(status1, Status::SUCCESS);
409     SyncInfo syncInfo;
410     auto status = kvdbServiceImpl_->AddSubscribeInfo(appId, storeId, syncInfo);
411     ZLOGI("AddSubscribeInfoTest001 status = :%{public}d", status);
412     ASSERT_NE(status, Status::SUCCESS);
413 }
414 
415 /**
416 * @tc.name: RmvSubscribeInfoTest001
417 * @tc.desc: GetStoreIds
418 * @tc.type: FUNC
419 * @tc.author: wangbin
420 */
421 HWTEST_F(KvdbServiceImplTest, RmvSubscribeInfoTest001, TestSize.Level0)
422 {
423     ZLOGI("RmvSubscribeInfoTest001 start");
424     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
425     ASSERT_NE(kvStore, nullptr);
426     ASSERT_EQ(status1, Status::SUCCESS);
427     SyncInfo syncInfo;
428     auto status = kvdbServiceImpl_->RmvSubscribeInfo(appId, storeId, syncInfo);
429     ZLOGI("RmvSubscribeInfoTest001 status = :%{public}d", status);
430     ASSERT_NE(status, Status::SUCCESS);
431 }
432 
433 /**
434 * @tc.name: SubscribeTest001
435 * @tc.desc: GetStoreIds
436 * @tc.type: FUNC
437 * @tc.author: wangbin
438 */
439 HWTEST_F(KvdbServiceImplTest, SubscribeTest001, TestSize.Level0)
440 {
441     ZLOGI("SubscribeTest001 start");
442     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
443     ASSERT_NE(kvStore, nullptr);
444     ASSERT_EQ(status1, Status::SUCCESS);
445     sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
446     auto status = kvdbServiceImpl_->Subscribe(appId, storeId, observer);
447     ZLOGI("SubscribeTest001 status = :%{public}d", status);
448     ASSERT_EQ(status, Status::INVALID_ARGUMENT);
449 }
450 
451 /**
452 * @tc.name: UnsubscribeTest001
453 * @tc.desc: GetStoreIds
454 * @tc.type: FUNC
455 * @tc.author: wangbin
456 */
457 HWTEST_F(KvdbServiceImplTest, UnsubscribeTest001, TestSize.Level0)
458 {
459     ZLOGI("UnsubscribeTest001 start");
460     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
461     ASSERT_NE(kvStore, nullptr);
462     ASSERT_EQ(status1, Status::SUCCESS);
463     sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
464     auto status = kvdbServiceImpl_->Unsubscribe(appId, storeId, observer);
465     ZLOGI("UnsubscribeTest001 status = :%{public}d", status);
466     ASSERT_EQ(status, Status::SUCCESS);
467 }
468 
469 /**
470 * @tc.name: GetBackupPasswordTest001
471 * @tc.desc: GetStoreIds
472 * @tc.type: FUNC
473 * @tc.author: wangbin
474 */
475 HWTEST_F(KvdbServiceImplTest, GetBackupPasswordTest001, TestSize.Level0)
476 {
477     ZLOGI("GetBackupPasswordTest001 start");
478     auto status = manager.GetSingleKvStore(create, appId, storeId, kvStore);
479     ASSERT_NE(kvStore, nullptr);
480     ASSERT_EQ(status, Status::SUCCESS);
481 }
482 
483 /**
484 * @tc.name: BeforeCreateTest001
485 * @tc.desc: GetStoreIds
486 * @tc.type: FUNC
487 * @tc.author: wangbin
488 */
489 HWTEST_F(KvdbServiceImplTest, BeforeCreateTest001, TestSize.Level0)
490 {
491     ZLOGI("BeforeCreateTest001 start");
492     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
493     ASSERT_NE(kvStore, nullptr);
494     ASSERT_EQ(status1, Status::SUCCESS);
495     auto status = kvdbServiceImpl_->BeforeCreate(appId, storeId, create);
496     ZLOGI("BeforeCreateTest001 status = :%{public}d", status);
497     ASSERT_EQ(status, Status::SUCCESS);
498 }
499 
500 /**
501 * @tc.name: AfterCreateTest001
502 * @tc.desc: GetStoreIds
503 * @tc.type: FUNC
504 * @tc.author: wangbin
505 */
506 HWTEST_F(KvdbServiceImplTest, AfterCreateTest001, TestSize.Level0)
507 {
508     ZLOGI("AfterCreateTest001 start");
509     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
510     ASSERT_NE(kvStore, nullptr);
511     ASSERT_EQ(status1, Status::SUCCESS);
512     std::vector<uint8_t> password;
513     auto status = kvdbServiceImpl_->AfterCreate(appId, storeId, create, password);
514     ZLOGI("AfterCreateTest001 status = :%{public}d", status);
515     ASSERT_EQ(status, Status::SUCCESS);
516 }
517 
518 /**
519 * @tc.name: OnAppExitTest001
520 * @tc.desc: GetStoreIds
521 * @tc.type: FUNC
522 * @tc.author: wangbin
523 */
524 HWTEST_F(KvdbServiceImplTest, OnAppExitTest001, TestSize.Level0)
525 {
526     ZLOGI("OnAppExitTest001 start");
527     Status status1 = manager.GetSingleKvStore(create, appId, storeId, kvStore);
528     ASSERT_NE(kvStore, nullptr);
529     ASSERT_EQ(status1, Status::SUCCESS);
530     pid_t uid = 1;
531     pid_t pid = 2;
532     const char **perms = new const char *[2];
533     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
534     perms[1] = "ohos.permission.ACCESS_SERVICE_DM";
535     TokenInfoParams infoInstance = {
536         .dcapsNum = 0,
537         .permsNum = 2,
538         .aclsNum = 0,
539         .dcaps = nullptr,
540         .perms = perms,
541         .acls = nullptr,
542         .processName = "distributed_data_test",
543         .aplStr = "system_basic",
544     };
545     uint32_t tokenId = GetAccessTokenId(&infoInstance);
546     auto status = kvdbServiceImpl_->OnAppExit(uid, pid, tokenId, appId);
547     ZLOGI("OnAppExitTest001 status = :%{public}d", status);
548     ASSERT_EQ(status, Status::SUCCESS);
549 }
550 
551 /**
552 * @tc.name: OnUserChangeTest001
553 * @tc.desc: GetStoreIds
554 * @tc.type: FUNC
555 * @tc.author: wangbin
556 */
557 HWTEST_F(KvdbServiceImplTest, OnUserChangeTest001, TestSize.Level0)
558 {
559     ZLOGI("OnUserChangeTest001 start");
560     uint32_t code = 1;
561     std::string user = "OH_USER_test";
562     std::string account = "OH_ACCOUNT_test";
563     auto status = kvdbServiceImpl_->OnUserChange(code, user, account);
564     ZLOGI("OnUserChangeTest001 status = :%{public}d", status);
565     ASSERT_EQ(status, Status::SUCCESS);
566 }
567 
568 /**
569 * @tc.name: OnReadyTest001
570 * @tc.desc: GetStoreIds
571 * @tc.type: FUNC
572 * @tc.author: wangbin
573 */
574 HWTEST_F(KvdbServiceImplTest, OnReadyTest001, TestSize.Level0)
575 {
576     ZLOGI("OnReadyTest001 start");
577     std::string device = "OH_device_test";
578     auto status = kvdbServiceImpl_->OnReady(device);
579     ZLOGI("OnReadyTest001 status = :%{public}d", status);
580     ASSERT_EQ(status, Status::SUCCESS);
581     status = kvdbServiceImpl_->OnSessionReady(device);
582     ASSERT_EQ(status, Status::SUCCESS);
583 }
584 
585 /**
586 * @tc.name: ResolveAutoLaunch
587 * @tc.desc: ResolveAutoLaunch function test.
588 * @tc.type: FUNC
589 * @tc.author: SQL
590 */
591 HWTEST_F(KvdbServiceImplTest, ResolveAutoLaunch, TestSize.Level0)
592 {
593     StoreId id1;
594     id1.storeId = "id1";
595     Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
596     EXPECT_NE(kvStore, nullptr);
597     EXPECT_EQ(status, Status::SUCCESS);
598     std::string identifier = "identifier";
599     DistributedKv::KVDBServiceImpl::DBLaunchParam launchParam;
600     auto result = kvdbServiceImpl_->ResolveAutoLaunch(identifier, launchParam);
601     EXPECT_EQ(result, Status::STORE_NOT_FOUND);
602     std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(1, 0);
603     Bootstrap::GetInstance().LoadDirectory();
604     Bootstrap::GetInstance().LoadCheckers();
605     DistributedKv::KvStoreMetaManager::GetInstance().BindExecutor(executors);
606     DistributedKv::KvStoreMetaManager::GetInstance().InitMetaParameter();
607     DistributedKv::KvStoreMetaManager::GetInstance().InitMetaListener();
608     result = kvdbServiceImpl_->ResolveAutoLaunch(identifier, launchParam);
609     EXPECT_EQ(result, Status::SUCCESS);
610 }
611 
612 /**
613 * @tc.name: PutSwitch
614 * @tc.desc: PutSwitch function test.
615 * @tc.type: FUNC
616 * @tc.author: SQL
617 */
618 HWTEST_F(KvdbServiceImplTest, PutSwitch, TestSize.Level0)
619 {
620     StoreId id1;
621     id1.storeId = "id1";
622     Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
623     ASSERT_NE(kvStore, nullptr);
624     ASSERT_EQ(status, Status::SUCCESS);
625     DistributedKv::SwitchData switchData;
626     status = kvdbServiceImpl_->PutSwitch(appId, switchData);
627     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
628     switchData.value = DeviceMatrix::INVALID_VALUE;
629     switchData.length = DeviceMatrix::INVALID_LEVEL;
630     status = kvdbServiceImpl_->PutSwitch(appId, switchData);
631     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
632     switchData.value = DeviceMatrix::INVALID_MASK;
633     switchData.length = DeviceMatrix::INVALID_LENGTH;
634     status = kvdbServiceImpl_->PutSwitch(appId, switchData);
635     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
636     switchData.value = DeviceMatrix::INVALID_VALUE;
637     switchData.length = DeviceMatrix::INVALID_LENGTH;
638     status = kvdbServiceImpl_->PutSwitch(appId, switchData);
639     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
640     switchData.value = DeviceMatrix::INVALID_MASK;
641     switchData.length = DeviceMatrix::INVALID_LEVEL;
642     status = kvdbServiceImpl_->PutSwitch(appId, switchData);
643     EXPECT_EQ(status, Status::SUCCESS);
644     std::string networkId = "networkId";
645     status = kvdbServiceImpl_->GetSwitch(appId, networkId, switchData);
646     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
647 }
648 
649 /**
650 * @tc.name: DoCloudSync
651 * @tc.desc: DoCloudSync error function test.
652 * @tc.type: FUNC
653 * @tc.author: SQL
654 */
655 HWTEST_F(KvdbServiceImplTest, DoCloudSync, TestSize.Level0)
656 {
657     StoreId id1;
658     id1.storeId = "id1";
659     Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
660     ASSERT_NE(kvStore, nullptr);
661     ASSERT_EQ(status, Status::SUCCESS);
662     StoreMetaData metaData;
663     SyncInfo syncInfo;
664     status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
665     EXPECT_EQ(status, Status::NOT_SUPPORT);
666     syncInfo.devices = {"device1", "device2"};
667     syncInfo.query = "query";
668     metaData.enableCloud = true;
669     status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
670     EXPECT_EQ(status, Status::CLOUD_DISABLED);
671 }
672 
673 /**
674 * @tc.name: ConvertDbStatus
675 * @tc.desc: ConvertDbStatus test the return result of input with different values.
676 * @tc.type: FUNC
677 * @tc.author: SQL
678 */
679 HWTEST_F(KvdbServiceImplTest, ConvertDbStatus, TestSize.Level0)
680 {
681     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::BUSY), Status::DB_ERROR);
682     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::DB_ERROR), Status::DB_ERROR);
683     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::OK), Status::SUCCESS);
684     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_ARGS), Status::INVALID_ARGUMENT);
685     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::NOT_FOUND), Status::KEY_NOT_FOUND);
686     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_VALUE_FIELDS), Status::INVALID_VALUE_FIELDS);
687     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_FIELD_TYPE), Status::INVALID_FIELD_TYPE);
688     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::CONSTRAIN_VIOLATION), Status::CONSTRAIN_VIOLATION);
689     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_FORMAT), Status::INVALID_FORMAT);
690     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_QUERY_FORMAT), Status::INVALID_QUERY_FORMAT);
691     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_QUERY_FIELD), Status::INVALID_QUERY_FIELD);
692     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::NOT_SUPPORT), Status::NOT_SUPPORT);
693     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::TIME_OUT), Status::TIME_OUT);
694     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::OVER_MAX_LIMITS), Status::OVER_MAX_LIMITS);
695     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::EKEYREVOKED_ERROR), Status::SECURITY_LEVEL_ERROR);
696     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::SECURITY_OPTION_CHECK_ERROR), Status::SECURITY_LEVEL_ERROR);
697     EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::SCHEMA_VIOLATE_VALUE), Status::ERROR);
698 }
699 
700 /**
701 * @tc.name: ConvertDBMode
702 * @tc.desc: ConvertDBMode test the return result of input with different values.
703 * @tc.type: FUNC
704 * @tc.author: SQL
705 */
706 HWTEST_F(KvdbServiceImplTest, ConvertDBMode, TestSize.Level0)
707 {
708     auto status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PUSH);
709     EXPECT_EQ(status, DBMode::SYNC_MODE_PUSH_ONLY);
710     status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PULL);
711     EXPECT_EQ(status, DBMode::SYNC_MODE_PULL_ONLY);
712     status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PUSH_PULL);
713     EXPECT_EQ(status, DBMode::SYNC_MODE_PUSH_PULL);
714 }
715 
716 /**
717 * @tc.name: ConvertGeneralSyncMode
718 * @tc.desc: ConvertGeneralSyncMode test the return result of input with different values.
719 * @tc.type: FUNC
720 * @tc.author: SQL
721 */
722 HWTEST_F(KvdbServiceImplTest, ConvertGeneralSyncMode, TestSize.Level0)
723 {
724     auto status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_SUBSCRIBE);
725     EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_SUBSCRIBE_REMOTE);
726     status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_UNSUBSCRIBE);
727     EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_UNSUBSCRIBE_REMOTE);
728     status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_SYNC);
729     EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PUSH);
730     status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PULL, SyncAction::ACTION_SYNC);
731     EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PULL);
732     status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH_PULL, SyncAction::ACTION_SYNC);
733     EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PULL_PUSH);
734     auto action = static_cast<SyncAction>(SyncAction::ACTION_UNSUBSCRIBE + 1);
735     status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, action);
736     EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_END);
737 }
738 
739 /**
740 * @tc.name: ConvertType
741 * @tc.desc: ConvertType test the return result of input with different values.
742 * @tc.type: FUNC
743 * @tc.author: SQL
744 */
745 HWTEST_F(KvdbServiceImplTest, ConvertType, TestSize.Level0)
746 {
747     auto status = kvdbServiceImpl_->ConvertType(SyncMode::PUSH);
748     EXPECT_EQ(status, ChangeType::CHANGE_LOCAL);
749     status = kvdbServiceImpl_->ConvertType(SyncMode::PULL);
750     EXPECT_EQ(status, ChangeType::CHANGE_REMOTE);
751     status = kvdbServiceImpl_->ConvertType(SyncMode::PUSH_PULL);
752     EXPECT_EQ(status, ChangeType::CHANGE_ALL);
753     auto action = static_cast<SyncMode>(SyncMode::PUSH_PULL + 1);
754     status = kvdbServiceImpl_->ConvertType(action);
755     EXPECT_EQ(status, ChangeType::CHANGE_ALL);
756 }
757 
758 /**
759 * @tc.name: ConvertAction
760 * @tc.desc: ConvertAction test the return result of input with different values.
761 * @tc.type: FUNC
762 * @tc.author: SQL
763 */
764 HWTEST_F(KvdbServiceImplTest, ConvertAction, TestSize.Level0)
765 {
766     auto status = kvdbServiceImpl_->ConvertAction(Action::INSERT);
767     EXPECT_EQ(status, SwitchState::INSERT);
768     status = kvdbServiceImpl_->ConvertAction(Action::UPDATE);
769     EXPECT_EQ(status, SwitchState::UPDATE);
770     status = kvdbServiceImpl_->ConvertAction(Action::DELETE);
771     EXPECT_EQ(status, SwitchState::DELETE);
772     auto action = static_cast<Action>(Action::DELETE + 1);
773     status = kvdbServiceImpl_->ConvertAction(action);
774     EXPECT_EQ(status, SwitchState::INSERT);
775 }
776 
777 /**
778 * @tc.name: GetSyncMode
779 * @tc.desc: GetSyncMode test the return result of input with different values.
780 * @tc.type: FUNC
781 * @tc.author: SQL
782 */
783 HWTEST_F(KvdbServiceImplTest, GetSyncMode, TestSize.Level0)
784 {
785     auto status = kvdbServiceImpl_->GetSyncMode(true, true);
786     EXPECT_EQ(status, SyncMode::PUSH_PULL);
787     status = kvdbServiceImpl_->GetSyncMode(true, false);
788     EXPECT_EQ(status, SyncMode::PUSH);
789     status = kvdbServiceImpl_->GetSyncMode(false, true);
790     EXPECT_EQ(status, SyncMode::PULL);
791     status = kvdbServiceImpl_->GetSyncMode(false, false);
792     EXPECT_EQ(status, SyncMode::PUSH_PULL);
793 }
794 } // namespace DistributedDataTest
795 } // namespace OHOS::Test