1 /*
2 * Copyright (c) 2022 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 #include <condition_variable>
16 #include <gtest/gtest.h>
17 #include <vector>
18
19 #include "block_data.h"
20 #include "dev_manager.h"
21 #include "device_manager.h"
22 #include "distributed_kv_data_manager.h"
23 #include "dm_device_info.h"
24 #include "file_ex.h"
25 #include "kv_store_nb_delegate.h"
26 #include "single_store_impl.h"
27 #include "store_factory.h"
28 #include "store_manager.h"
29 #include "sys/stat.h"
30 #include "types.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::DistributedKv;
34 using DBStatus = DistributedDB::DBStatus;
35 using DBStore = DistributedDB::KvStoreNbDelegate;
36 using SyncCallback = KvStoreSyncCallback;
37 using DevInfo = OHOS::DistributedHardware::DmDeviceInfo;
38 namespace OHOS::Test {
39
Random(int32_t len)40 std::vector<uint8_t> Random(int32_t len)
41 {
42 return std::vector<uint8_t>(len, 'a');
43 }
44
45 class SingleStoreImplTest : public testing::Test {
46 public:
47 class TestObserver : public KvStoreObserver {
48 public:
TestObserver()49 TestObserver()
50 {
51 // The time interval parameter is 5.
52 data_ = std::make_shared<OHOS::BlockData<bool>>(5, false);
53 }
OnChange(const ChangeNotification & notification)54 void OnChange(const ChangeNotification ¬ification) override
55 {
56 insert_ = notification.GetInsertEntries();
57 update_ = notification.GetUpdateEntries();
58 delete_ = notification.GetDeleteEntries();
59 deviceId_ = notification.GetDeviceId();
60 bool value = true;
61 data_->SetValue(value);
62 }
63 std::vector<Entry> insert_;
64 std::vector<Entry> update_;
65 std::vector<Entry> delete_;
66 std::string deviceId_;
67
68 std::shared_ptr<OHOS::BlockData<bool>> data_;
69 };
70
71 static void SetUpTestCase(void);
72 static void TearDownTestCase(void);
73 void SetUp();
74 void TearDown();
75
76 std::shared_ptr<SingleKvStore> CreateKVStore(std::string storeIdTest, KvStoreType type, bool encrypt, bool backup);
77 std::shared_ptr<SingleStoreImpl> CreateKVStore(bool autosync = false);
78 std::shared_ptr<SingleKvStore> kvStore_;
79 static constexpr int MAX_RESULTSET_SIZE = 8;
80 };
81
SetUpTestCase(void)82 void SingleStoreImplTest::SetUpTestCase(void)
83 {
84 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
85 mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
86 }
87
TearDownTestCase(void)88 void SingleStoreImplTest::TearDownTestCase(void)
89 {
90 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
91 StoreManager::GetInstance().Delete({ "SingleStoreImplTest" }, { "SingleKVStore" }, baseDir);
92
93 (void)remove("/data/service/el1/public/database/SingleStoreImplTest/key");
94 (void)remove("/data/service/el1/public/database/SingleStoreImplTest/kvdb");
95 (void)remove("/data/service/el1/public/database/SingleStoreImplTest");
96 }
97
SetUp(void)98 void SingleStoreImplTest::SetUp(void)
99 {
100 kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION, false, true);
101 if (kvStore_ == nullptr) {
102 kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION, false, true);
103 }
104 ASSERT_NE(kvStore_, nullptr);
105 }
106
TearDown(void)107 void SingleStoreImplTest::TearDown(void)
108 {
109 AppId appId = { "SingleStoreImplTest" };
110 StoreId storeId = { "SingleKVStore" };
111 kvStore_ = nullptr;
112 auto status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
113 ASSERT_EQ(status, SUCCESS);
114 auto baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
115 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
116 ASSERT_EQ(status, SUCCESS);
117 }
118
CreateKVStore(std::string storeIdTest,KvStoreType type,bool encrypt,bool backup)119 std::shared_ptr<SingleKvStore> SingleStoreImplTest::CreateKVStore(
120 std::string storeIdTest, KvStoreType type, bool encrypt, bool backup)
121 {
122 Options options;
123 options.kvStoreType = type;
124 options.securityLevel = S1;
125 options.encrypt = encrypt;
126 options.area = EL1;
127 options.backup = backup;
128 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
129
130 AppId appId = { "SingleStoreImplTest" };
131 StoreId storeId = { storeIdTest };
132 Status status = StoreManager::GetInstance().Delete(appId, storeId, options.baseDir);
133 return StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
134 }
135
CreateKVStore(bool autosync)136 std::shared_ptr<SingleStoreImpl> SingleStoreImplTest::CreateKVStore(bool autosync)
137 {
138 AppId appId = { "SingleStoreImplTest" };
139 StoreId storeId = { "DestructorTest" };
140 std::shared_ptr<SingleStoreImpl> kvStore;
141 Options options;
142 options.kvStoreType = SINGLE_VERSION;
143 options.securityLevel = S2;
144 options.area = EL1;
145 options.autoSync = autosync;
146 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
147 StoreFactory storeFactory;
148 auto dbManager = storeFactory.GetDBManager(options.baseDir, appId);
149 auto dbPassword = SecurityManager::GetInstance().GetDBPassword(storeId.storeId, options.baseDir, options.encrypt);
150 DBStatus dbStatus = DBStatus::DB_ERROR;
151 dbManager->GetKvStore(storeId, storeFactory.GetDBOption(options, dbPassword),
152 [&dbManager, &kvStore, &appId, &dbStatus, &options, &storeFactory](auto status, auto *store) {
153 dbStatus = status;
154 if (store == nullptr) {
155 return;
156 }
157 auto release = [dbManager](auto *store) {
158 dbManager->CloseKvStore(store);
159 };
160 auto dbStore = std::shared_ptr<DBStore>(store, release);
161 storeFactory.SetDbConfig(dbStore);
162 const Convertor &convertor = *(storeFactory.convertors_[options.kvStoreType]);
163 kvStore = std::make_shared<SingleStoreImpl>(dbStore, appId, options, convertor);
164 });
165 return kvStore;
166 }
167
168 /**
169 * @tc.name: GetStoreId
170 * @tc.desc: get the store id of the kv store
171 * @tc.type: FUNC
172 * @tc.require: I4XVQQ
173 * @tc.author: Sven Wang
174 */
175 HWTEST_F(SingleStoreImplTest, GetStoreId, TestSize.Level0)
176 {
177 ASSERT_NE(kvStore_, nullptr);
178 auto storeId = kvStore_->GetStoreId();
179 ASSERT_EQ(storeId.storeId, "SingleKVStore");
180 }
181
182 /**
183 * @tc.name: GetSubUser
184 * @tc.desc: get the subUser of the kv store
185 * @tc.type: FUNC
186 */
187 HWTEST_F(SingleStoreImplTest, GetSubUser, TestSize.Level0)
188 {
189 ASSERT_NE(kvStore_, nullptr);
190 auto subUser = kvStore_->GetSubUser();
191 ASSERT_EQ(subUser, 0);
192 }
193
194 /**
195 * @tc.name: Put
196 * @tc.desc: put key-value data to the kv store
197 * @tc.type: FUNC
198 * @tc.require: I4XVQQ
199 * @tc.author: Sven Wang
200 */
201 HWTEST_F(SingleStoreImplTest, Put, TestSize.Level0)
202 {
203 ASSERT_NE(kvStore_, nullptr);
204 auto status = kvStore_->Put({ "Put Test" }, { "Put Value" });
205 ASSERT_EQ(status, SUCCESS);
206 status = kvStore_->Put({ " Put Test" }, { "Put2 Value" });
207 ASSERT_EQ(status, SUCCESS);
208 Value value;
209 status = kvStore_->Get({ "Put Test" }, value);
210 ASSERT_EQ(status, SUCCESS);
211 ASSERT_EQ(value.ToString(), "Put2 Value");
212 }
213
214 /**
215 * @tc.name: Put_Invalid_Key
216 * @tc.desc: put invalid key-value data to the device kv store and single kv store
217 * @tc.type: FUNC
218 * @tc.require: I4XVQQ
219 * @tc.author: wu fengshan
220 */
221 HWTEST_F(SingleStoreImplTest, Put_Invalid_Key, TestSize.Level0)
222 {
223 std::shared_ptr<SingleKvStore> kvStore;
224 AppId appId = { "SingleStoreImplTest" };
225 StoreId storeId = { "DeviceKVStore" };
226 kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
227 ASSERT_NE(kvStore, nullptr);
228
229 size_t maxDevKeyLen = 897;
230 std::string str(maxDevKeyLen, 'a');
231 Blob key(str);
232 Blob value("test_value");
233 Status status = kvStore->Put(key, value);
234 EXPECT_EQ(status, INVALID_ARGUMENT);
235
236 Blob key1("");
237 Blob value1("test_value1");
238 status = kvStore->Put(key1, value1);
239 EXPECT_EQ(status, INVALID_ARGUMENT);
240
241 kvStore = nullptr;
242 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
243 ASSERT_EQ(status, SUCCESS);
244 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
245 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
246 ASSERT_EQ(status, SUCCESS);
247
248 size_t maxSingleKeyLen = 1025;
249 std::string str1(maxSingleKeyLen, 'b');
250 Blob key2(str1);
251 Blob value2("test_value2");
252 status = kvStore_->Put(key2, value2);
253 EXPECT_EQ(status, INVALID_ARGUMENT);
254
255 status = kvStore_->Put(key1, value1);
256 EXPECT_EQ(status, INVALID_ARGUMENT);
257 }
258
259 /**
260 * @tc.name: PutBatch
261 * @tc.desc: put some key-value data to the kv store
262 * @tc.type: FUNC
263 * @tc.require: I4XVQQ
264 * @tc.author: Sven Wang
265 */
266 HWTEST_F(SingleStoreImplTest, PutBatch, TestSize.Level0)
267 {
268 ASSERT_NE(kvStore_, nullptr);
269 std::vector<Entry> entries;
270 for (int i = 0; i < 10; ++i) {
271 Entry entry;
272 entry.key = std::to_string(i).append("_k");
273 entry.value = std::to_string(i).append("_v");
274 entries.push_back(entry);
275 }
276 auto status = kvStore_->PutBatch(entries);
277 ASSERT_EQ(status, SUCCESS);
278 }
279
280 /**
281 * @tc.name: GetStoreId
282 * @tc.desc: test IsRebuild
283 * @tc.type: FUNC
284 */
285 HWTEST_F(SingleStoreImplTest, IsRebuild, TestSize.Level0)
286 {
287 ASSERT_NE(kvStore_, nullptr);
288 auto status = kvStore_->IsRebuild();
289 ASSERT_EQ(status, false);
290 }
291
292 /**
293 * @tc.name: PutBatch001
294 * @tc.desc: entry.value.Size() > MAX_VALUE_LENGTH
295 * @tc.type: FUNC
296 */
297 HWTEST_F(SingleStoreImplTest, PutBatch001, TestSize.Level1)
298 {
299 ASSERT_NE(kvStore_, nullptr);
300 size_t totalLength = SingleStoreImpl::MAX_VALUE_LENGTH + 1; // create an out-of-limit large number
301 char fillChar = 'a';
302 std::string longString(totalLength, fillChar);
303 std::vector<Entry> entries;
304 Entry entry;
305 entry.key = "PutBatch001_test";
306 entry.value = longString;
307 entries.push_back(entry);
308 auto status = kvStore_->PutBatch(entries);
309 ASSERT_EQ(status, INVALID_ARGUMENT);
310 entries.clear();
311 Entry entrys;
312 entrys.key = "";
313 entrys.value = "PutBatch001_test_value";
314 entries.push_back(entrys);
315 status = kvStore_->PutBatch(entries);
316 ASSERT_EQ(status, INVALID_ARGUMENT);
317 }
318
319 /**
320 * @tc.name: Delete
321 * @tc.desc: delete the value of the key
322 * @tc.type: FUNC
323 * @tc.require: I4XVQQ
324 * @tc.author: Sven Wang
325 */
326 HWTEST_F(SingleStoreImplTest, Delete, TestSize.Level0)
327 {
328 ASSERT_NE(kvStore_, nullptr);
329 auto status = kvStore_->Put({ "Put Test" }, { "Put Value" });
330 ASSERT_EQ(status, SUCCESS);
331 Value value;
332 status = kvStore_->Get({ "Put Test" }, value);
333 ASSERT_EQ(status, SUCCESS);
334 ASSERT_EQ(std::string("Put Value"), value.ToString());
335 status = kvStore_->Delete({ "Put Test" });
336 ASSERT_EQ(status, SUCCESS);
337 value = {};
338 status = kvStore_->Get({ "Put Test" }, value);
339 ASSERT_EQ(status, KEY_NOT_FOUND);
340 ASSERT_EQ(std::string(""), value.ToString());
341 }
342
343 /**
344 * @tc.name: DeleteBatch
345 * @tc.desc: delete the values of the keys
346 * @tc.type: FUNC
347 * @tc.require: I4XVQQ
348 * @tc.author: Sven Wang
349 */
350 HWTEST_F(SingleStoreImplTest, DeleteBatch, TestSize.Level0)
351 {
352 ASSERT_NE(kvStore_, nullptr);
353 std::vector<Entry> entries;
354 for (int i = 0; i < 10; ++i) {
355 Entry entry;
356 entry.key = std::to_string(i).append("_k");
357 entry.value = std::to_string(i).append("_v");
358 entries.push_back(entry);
359 }
360 auto status = kvStore_->PutBatch(entries);
361 ASSERT_EQ(status, SUCCESS);
362 std::vector<Key> keys;
363 for (int i = 0; i < 10; ++i) {
364 Key key = std::to_string(i).append("_k");
365 keys.push_back(key);
366 }
367 status = kvStore_->DeleteBatch(keys);
368 ASSERT_EQ(status, SUCCESS);
369 for (int i = 0; i < 10; ++i) {
370 Value value;
371 status = kvStore_->Get(keys[i], value);
372 ASSERT_EQ(status, KEY_NOT_FOUND);
373 ASSERT_EQ(value.ToString(), std::string(""));
374 }
375 }
376
377 /**
378 * @tc.name: Transaction
379 * @tc.desc: do transaction
380 * @tc.type: FUNC
381 * @tc.require: I4XVQQ
382 * @tc.author: Sven Wang
383 */
384 HWTEST_F(SingleStoreImplTest, Transaction, TestSize.Level0)
385 {
386 ASSERT_NE(kvStore_, nullptr);
387 auto status = kvStore_->StartTransaction();
388 ASSERT_EQ(status, SUCCESS);
389 status = kvStore_->Commit();
390 ASSERT_EQ(status, SUCCESS);
391
392 status = kvStore_->StartTransaction();
393 ASSERT_EQ(status, SUCCESS);
394 status = kvStore_->Rollback();
395 ASSERT_EQ(status, SUCCESS);
396 }
397
398 /**
399 * @tc.name: SubscribeKvStore
400 * @tc.desc: subscribe local
401 * @tc.type: FUNC
402 * @tc.require: I4XVQQ
403 * @tc.author: Sven Wang
404 */
405 HWTEST_F(SingleStoreImplTest, SubscribeKvStore, TestSize.Level0)
406 {
407 ASSERT_NE(kvStore_, nullptr);
408 auto observer = std::make_shared<TestObserver>();
409 auto status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
410 ASSERT_EQ(status, SUCCESS);
411 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
412 ASSERT_EQ(status, SUCCESS);
413 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_CLOUD, observer);
414 ASSERT_EQ(status, SUCCESS);
415 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
416 ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
417 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
418 ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
419 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_CLOUD, observer);
420 ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
421 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
422 ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
423 bool invalidValue = false;
424 observer->data_->Clear(invalidValue);
425 status = kvStore_->Put({ "Put Test" }, { "Put Value" });
426 ASSERT_EQ(status, SUCCESS);
427 ASSERT_TRUE(observer->data_->GetValue());
428 ASSERT_EQ(observer->insert_.size(), 1);
429 ASSERT_EQ(observer->update_.size(), 0);
430 ASSERT_EQ(observer->delete_.size(), 0);
431 observer->data_->Clear(invalidValue);
432 status = kvStore_->Put({ "Put Test" }, { "Put Value1" });
433 ASSERT_EQ(status, SUCCESS);
434 ASSERT_TRUE(observer->data_->GetValue());
435 ASSERT_EQ(observer->insert_.size(), 0);
436 ASSERT_EQ(observer->update_.size(), 1);
437 ASSERT_EQ(observer->delete_.size(), 0);
438 observer->data_->Clear(invalidValue);
439 status = kvStore_->Delete({ "Put Test" });
440 ASSERT_EQ(status, SUCCESS);
441 ASSERT_TRUE(observer->data_->GetValue());
442 ASSERT_EQ(observer->insert_.size(), 0);
443 ASSERT_EQ(observer->update_.size(), 0);
444 ASSERT_EQ(observer->delete_.size(), 1);
445 }
446
447 /**
448 * @tc.name: SubscribeKvStore002
449 * @tc.desc: subscribe local
450 * @tc.type: FUNC
451 * @tc.require: I4XVQQ
452 * @tc.author: Hollokin
453 */
454 HWTEST_F(SingleStoreImplTest, SubscribeKvStore002, TestSize.Level0)
455 {
456 ASSERT_NE(kvStore_, nullptr);
457 std::shared_ptr<TestObserver> subscribedObserver;
458 std::shared_ptr<TestObserver> unSubscribedObserver;
459 for (int i = 0; i < 15; ++i) {
460 auto observer = std::make_shared<TestObserver>();
461 auto status1 = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
462 auto status2 = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
463 if (i < 8) {
464 ASSERT_EQ(status1, SUCCESS);
465 ASSERT_EQ(status2, SUCCESS);
466 subscribedObserver = observer;
467 } else {
468 ASSERT_EQ(status1, OVER_MAX_LIMITS);
469 ASSERT_EQ(status2, OVER_MAX_LIMITS);
470 unSubscribedObserver = observer;
471 }
472 }
473
474 auto status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
475 ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
476
477 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, {});
478 ASSERT_EQ(status, INVALID_ARGUMENT);
479
480 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, subscribedObserver);
481 ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
482
483 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, subscribedObserver);
484 ASSERT_EQ(status, SUCCESS);
485
486 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
487 ASSERT_EQ(status, SUCCESS);
488 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
489 ASSERT_EQ(status, SUCCESS);
490
491 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_ALL, subscribedObserver);
492 ASSERT_EQ(status, SUCCESS);
493 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, unSubscribedObserver);
494 ASSERT_EQ(status, SUCCESS);
495 subscribedObserver = unSubscribedObserver;
496 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
497 ASSERT_EQ(status, SUCCESS);
498 auto observer = std::make_shared<TestObserver>();
499 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
500 ASSERT_EQ(status, SUCCESS);
501 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
502 ASSERT_EQ(status, SUCCESS);
503 observer = std::make_shared<TestObserver>();
504 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
505 ASSERT_EQ(status, OVER_MAX_LIMITS);
506 }
507
508 /**
509 * @tc.name: SubscribeKvStore003
510 * @tc.desc: isClientSync_
511 * @tc.type: FUNC
512 */
513 HWTEST_F(SingleStoreImplTest, SubscribeKvStore003, TestSize.Level0)
514 {
515 auto observer = std::make_shared<TestObserver>();
516 std::shared_ptr<SingleStoreImpl> kvStore;
517 kvStore = CreateKVStore();
518 ASSERT_NE(kvStore, nullptr);
519 kvStore->isClientSync_ = true;
520 auto status = kvStore->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
521 ASSERT_EQ(status, SUCCESS);
522 }
523
524 /**
525 * @tc.name: UnsubscribeKvStore
526 * @tc.desc: unsubscribe
527 * @tc.type: FUNC
528 * @tc.require: I4XVQQ
529 * @tc.author: Sven Wang
530 */
531 HWTEST_F(SingleStoreImplTest, UnsubscribeKvStore, TestSize.Level0)
532 {
533 ASSERT_NE(kvStore_, nullptr);
534 auto observer = std::make_shared<TestObserver>();
535 auto status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
536 ASSERT_EQ(status, SUCCESS);
537 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
538 ASSERT_EQ(status, SUCCESS);
539 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_CLOUD, observer);
540 ASSERT_EQ(status, SUCCESS);
541 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
542 ASSERT_EQ(status, STORE_NOT_SUBSCRIBE);
543 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
544 ASSERT_EQ(status, SUCCESS);
545 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
546 ASSERT_EQ(status, STORE_NOT_SUBSCRIBE);
547 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
548 ASSERT_EQ(status, STORE_NOT_SUBSCRIBE);
549 status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
550 ASSERT_EQ(status, SUCCESS);
551 status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
552 ASSERT_EQ(status, SUCCESS);
553 }
554
555 /**
556 * @tc.name: GetEntries
557 * @tc.desc: get entries by prefix
558 * @tc.type: FUNC
559 * @tc.require: I4XVQQ
560 * @tc.author: Sven Wang
561 */
562 HWTEST_F(SingleStoreImplTest, GetEntries_Prefix, TestSize.Level0)
563 {
564 ASSERT_NE(kvStore_, nullptr);
565 std::vector<Entry> input;
566 for (int i = 0; i < 10; ++i) {
567 Entry entry;
568 entry.key = std::to_string(i).append("_k");
569 entry.value = std::to_string(i).append("_v");
570 input.push_back(entry);
571 }
572 auto status = kvStore_->PutBatch(input);
573 ASSERT_EQ(status, SUCCESS);
574 std::vector<Entry> output;
575 status = kvStore_->GetEntries({ "" }, output);
576 ASSERT_EQ(status, SUCCESS);
__anon81e1e1f90302(const Entry &entry, const Entry &sentry) 577 std::sort(output.begin(), output.end(), [](const Entry &entry, const Entry &sentry) {
578 return entry.key.Data() < sentry.key.Data();
579 });
580 for (int i = 0; i < 10; ++i) {
581 ASSERT_TRUE(input[i].key == output[i].key);
582 ASSERT_TRUE(input[i].value == output[i].value);
583 }
584 }
585
586 /**
587 * @tc.name: GetEntries_Less_Prefix
588 * @tc.desc: get entries by prefix and the key size less than sizeof(uint32_t)
589 * @tc.type: FUNC
590 * @tc.require: I4XVQQ
591 * @tc.author: wu fengshan
592 */
593 HWTEST_F(SingleStoreImplTest, GetEntries_Less_Prefix, TestSize.Level0)
594 {
595 std::shared_ptr<SingleKvStore> kvStore;
596 AppId appId = { "SingleStoreImplTest" };
597 StoreId storeId = { "DeviceKVStore" };
598 kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
599 ASSERT_NE(kvStore, nullptr);
600
601 std::vector<Entry> input;
602 for (int i = 0; i < 10; ++i) {
603 Entry entry;
604 entry.key = std::to_string(i).append("_k");
605 entry.value = std::to_string(i).append("_v");
606 input.push_back(entry);
607 }
608 auto status = kvStore->PutBatch(input);
609 ASSERT_EQ(status, SUCCESS);
610 std::vector<Entry> output;
611 status = kvStore->GetEntries({ "1" }, output);
612 ASSERT_NE(output.empty(), true);
613 ASSERT_EQ(status, SUCCESS);
614
615 kvStore = nullptr;
616 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
617 ASSERT_EQ(status, SUCCESS);
618 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
619 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
620 ASSERT_EQ(status, SUCCESS);
621
622 status = kvStore_->PutBatch(input);
623 ASSERT_EQ(status, SUCCESS);
624 std::vector<Entry> output1;
625 status = kvStore_->GetEntries({ "1" }, output1);
626 ASSERT_NE(output1.empty(), true);
627 ASSERT_EQ(status, SUCCESS);
628 }
629
630 /**
631 * @tc.name: GetEntries_Greater_Prefix
632 * @tc.desc: get entries by prefix and the key size is greater than sizeof(uint32_t)
633 * @tc.type: FUNC
634 * @tc.require: I4XVQQ
635 * @tc.author: wu fengshan
636 */
637 HWTEST_F(SingleStoreImplTest, GetEntries_Greater_Prefix, TestSize.Level0)
638 {
639 std::shared_ptr<SingleKvStore> kvStore;
640 AppId appId = { "SingleStoreImplTest" };
641 StoreId storeId = { "DeviceKVStore" };
642 kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
643 ASSERT_NE(kvStore, nullptr);
644
645 size_t keyLen = sizeof(uint32_t);
646 std::vector<Entry> input;
647 for (int i = 1; i < 10; ++i) {
648 Entry entry;
649 std::string str(keyLen, i + '0');
650 entry.key = str;
651 entry.value = std::to_string(i).append("_v");
652 input.push_back(entry);
653 }
654 auto status = kvStore->PutBatch(input);
655 ASSERT_EQ(status, SUCCESS);
656 std::vector<Entry> output;
657 std::string str1(keyLen, '1');
658 status = kvStore->GetEntries(str1, output);
659 ASSERT_NE(output.empty(), true);
660 ASSERT_EQ(status, SUCCESS);
661
662 kvStore = nullptr;
663 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
664 ASSERT_EQ(status, SUCCESS);
665 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
666 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
667 ASSERT_EQ(status, SUCCESS);
668
669 status = kvStore_->PutBatch(input);
670 ASSERT_EQ(status, SUCCESS);
671 std::vector<Entry> output1;
672 status = kvStore_->GetEntries(str1, output1);
673 ASSERT_NE(output1.empty(), true);
674 ASSERT_EQ(status, SUCCESS);
675 }
676
677 /**
678 * @tc.name: GetEntries
679 * @tc.desc: get entries by query
680 * @tc.type: FUNC
681 * @tc.require: I4XVQQ
682 * @tc.author: Sven Wang
683 */
684 HWTEST_F(SingleStoreImplTest, GetEntries_DataQuery, TestSize.Level0)
685 {
686 ASSERT_NE(kvStore_, nullptr);
687 std::vector<Entry> input;
688 for (int i = 0; i < 10; ++i) {
689 Entry entry;
690 entry.key = std::to_string(i).append("_k");
691 entry.value = std::to_string(i).append("_v");
692 input.push_back(entry);
693 }
694 auto status = kvStore_->PutBatch(input);
695 ASSERT_EQ(status, SUCCESS);
696 DataQuery query;
697 query.InKeys({ "0_k", "1_k" });
698 std::vector<Entry> output;
699 status = kvStore_->GetEntries(query, output);
700 ASSERT_EQ(status, SUCCESS);
__anon81e1e1f90402(const Entry &entry, const Entry &sentry) 701 std::sort(output.begin(), output.end(), [](const Entry &entry, const Entry &sentry) {
702 return entry.key.Data() < sentry.key.Data();
703 });
704 ASSERT_LE(output.size(), 2);
705 for (size_t i = 0; i < output.size(); ++i) {
706 ASSERT_TRUE(input[i].key == output[i].key);
707 ASSERT_TRUE(input[i].value == output[i].value);
708 }
709 }
710
711 /**
712 * @tc.name: GetResultSet
713 * @tc.desc: get result set by prefix
714 * @tc.type: FUNC
715 * @tc.require: I4XVQQ
716 * @tc.author: Sven Wang
717 */
718 HWTEST_F(SingleStoreImplTest, GetResultSet_Prefix, TestSize.Level0)
719 {
720 ASSERT_NE(kvStore_, nullptr);
721 std::vector<Entry> input;
__anon81e1e1f90502(const Key &entry, const Key &sentry) 722 auto cmp = [](const Key &entry, const Key &sentry) {
723 return entry.Data() < sentry.Data();
724 };
725 std::map<Key, Value, decltype(cmp)> dictionary(cmp);
726 for (int i = 0; i < 10; ++i) {
727 Entry entry;
728 entry.key = std::to_string(i).append("_k");
729 entry.value = std::to_string(i).append("_v");
730 dictionary[entry.key] = entry.value;
731 input.push_back(entry);
732 }
733 auto status = kvStore_->PutBatch(input);
734 ASSERT_EQ(status, SUCCESS);
735 std::shared_ptr<KvStoreResultSet> output;
736 status = kvStore_->GetResultSet({ "" }, output);
737 ASSERT_EQ(status, SUCCESS);
738 ASSERT_NE(output, nullptr);
739 ASSERT_EQ(output->GetCount(), 10);
740 int count = 0;
741 while (output->MoveToNext()) {
742 count++;
743 Entry entry;
744 output->GetEntry(entry);
745 ASSERT_EQ(entry.value.Data(), dictionary[entry.key].Data());
746 }
747 ASSERT_EQ(count, output->GetCount());
748 }
749
750 /**
751 * @tc.name: GetResultSet
752 * @tc.desc: get result set by query
753 * @tc.type: FUNC
754 * @tc.require: I4XVQQ
755 * @tc.author: Sven Wang
756 */
757 HWTEST_F(SingleStoreImplTest, GetResultSet_Query, TestSize.Level0)
758 {
759 ASSERT_NE(kvStore_, nullptr);
760 std::vector<Entry> input;
__anon81e1e1f90602(const Key &entry, const Key &sentry) 761 auto cmp = [](const Key &entry, const Key &sentry) {
762 return entry.Data() < sentry.Data();
763 };
764 std::map<Key, Value, decltype(cmp)> dictionary(cmp);
765 for (int i = 0; i < 10; ++i) {
766 Entry entry;
767 entry.key = std::to_string(i).append("_k");
768 entry.value = std::to_string(i).append("_v");
769 dictionary[entry.key] = entry.value;
770 input.push_back(entry);
771 }
772 auto status = kvStore_->PutBatch(input);
773 ASSERT_EQ(status, SUCCESS);
774 DataQuery query;
775 query.InKeys({ "0_k", "1_k" });
776 std::shared_ptr<KvStoreResultSet> output;
777 status = kvStore_->GetResultSet(query, output);
778 ASSERT_EQ(status, SUCCESS);
779 ASSERT_NE(output, nullptr);
780 ASSERT_LE(output->GetCount(), 2);
781 int count = 0;
782 while (output->MoveToNext()) {
783 count++;
784 Entry entry;
785 output->GetEntry(entry);
786 ASSERT_EQ(entry.value.Data(), dictionary[entry.key].Data());
787 }
788 ASSERT_EQ(count, output->GetCount());
789 }
790
791 /**
792 * @tc.name: CloseResultSet
793 * @tc.desc: close the result set
794 * @tc.type: FUNC
795 * @tc.require: I4XVQQ
796 * @tc.author: Sven Wang
797 */
798 HWTEST_F(SingleStoreImplTest, CloseResultSet, TestSize.Level0)
799 {
800 ASSERT_NE(kvStore_, nullptr);
801 std::vector<Entry> input;
__anon81e1e1f90702(const Key &entry, const Key &sentry) 802 auto cmp = [](const Key &entry, const Key &sentry) {
803 return entry.Data() < sentry.Data();
804 };
805 std::map<Key, Value, decltype(cmp)> dictionary(cmp);
806 for (int i = 0; i < 10; ++i) {
807 Entry entry;
808 entry.key = std::to_string(i).append("_k");
809 entry.value = std::to_string(i).append("_v");
810 dictionary[entry.key] = entry.value;
811 input.push_back(entry);
812 }
813 auto status = kvStore_->PutBatch(input);
814 ASSERT_EQ(status, SUCCESS);
815 DataQuery query;
816 query.InKeys({ "0_k", "1_k" });
817 std::shared_ptr<KvStoreResultSet> output;
818 status = kvStore_->GetResultSet(query, output);
819 ASSERT_EQ(status, SUCCESS);
820 ASSERT_NE(output, nullptr);
821 ASSERT_LE(output->GetCount(), 2);
822 auto outputTmp = output;
823 status = kvStore_->CloseResultSet(output);
824 ASSERT_EQ(status, SUCCESS);
825 ASSERT_EQ(output, nullptr);
826 ASSERT_EQ(outputTmp->GetCount(), KvStoreResultSet::INVALID_COUNT);
827 ASSERT_EQ(outputTmp->GetPosition(), KvStoreResultSet::INVALID_POSITION);
828 ASSERT_EQ(outputTmp->MoveToFirst(), false);
829 ASSERT_EQ(outputTmp->MoveToLast(), false);
830 ASSERT_EQ(outputTmp->MoveToNext(), false);
831 ASSERT_EQ(outputTmp->MoveToPrevious(), false);
832 ASSERT_EQ(outputTmp->Move(1), false);
833 ASSERT_EQ(outputTmp->MoveToPosition(1), false);
834 ASSERT_EQ(outputTmp->IsFirst(), false);
835 ASSERT_EQ(outputTmp->IsLast(), false);
836 ASSERT_EQ(outputTmp->IsBeforeFirst(), false);
837 ASSERT_EQ(outputTmp->IsAfterLast(), false);
838 Entry entry;
839 ASSERT_EQ(outputTmp->GetEntry(entry), ALREADY_CLOSED);
840 }
841
842 /**
843 * @tc.name: CloseResultSet001
844 * @tc.desc: output = nullptr;
845 * @tc.type: FUNC
846 */
847 HWTEST_F(SingleStoreImplTest, CloseResultSet001, TestSize.Level0)
848 {
849 ASSERT_NE(kvStore_, nullptr);
850 std::shared_ptr<KvStoreResultSet> output;
851 output = nullptr;
852 auto status = kvStore_->CloseResultSet(output);
853 ASSERT_EQ(status, INVALID_ARGUMENT);
854 }
855
856 /**
857 * @tc.name: ResultSetMaxSizeTest
858 * @tc.desc: test if kv supports 8 resultSets at the same time
859 * @tc.type: FUNC
860 * @tc.require: I4XVQQ
861 * @tc.author: Yang Qing
862 */
863 HWTEST_F(SingleStoreImplTest, ResultSetMaxSizeTest_Query, TestSize.Level0)
864 {
865 ASSERT_NE(kvStore_, nullptr);
866 /**
867 * @tc.steps:step1. Put the entry into the database.
868 * @tc.expected: step1. Returns SUCCESS.
869 */
870 std::vector<Entry> input;
871 for (int i = 0; i < 10; ++i) {
872 Entry entry;
873 entry.key = "k_" + std::to_string(i);
874 entry.value = "v_" + std::to_string(i);
875 input.push_back(entry);
876 }
877 auto status = kvStore_->PutBatch(input);
878 ASSERT_EQ(status, SUCCESS);
879 /**
880 * @tc.steps:step2. Get the resultset.
881 * @tc.expected: step2. Returns SUCCESS.
882 */
883 DataQuery query;
884 query.KeyPrefix("k_");
885 std::vector<std::shared_ptr<KvStoreResultSet>> outputs(MAX_RESULTSET_SIZE + 1);
886 for (int i = 0; i < MAX_RESULTSET_SIZE; i++) {
887 std::shared_ptr<KvStoreResultSet> output;
888 status = kvStore_->GetResultSet(query, outputs[i]);
889 ASSERT_EQ(status, SUCCESS);
890 }
891 /**
892 * @tc.steps:step3. Get the resultset while resultset size is over the limit.
893 * @tc.expected: step3. Returns OVER_MAX_LIMITS.
894 */
895 status = kvStore_->GetResultSet(query, outputs[MAX_RESULTSET_SIZE]);
896 ASSERT_EQ(status, OVER_MAX_LIMITS);
897 /**
898 * @tc.steps:step4. Close the resultset and getting the resultset is retried
899 * @tc.expected: step4. Returns SUCCESS.
900 */
901 status = kvStore_->CloseResultSet(outputs[0]);
902 ASSERT_EQ(status, SUCCESS);
903 status = kvStore_->GetResultSet(query, outputs[MAX_RESULTSET_SIZE]);
904 ASSERT_EQ(status, SUCCESS);
905
906 for (int i = 1; i <= MAX_RESULTSET_SIZE; i++) {
907 status = kvStore_->CloseResultSet(outputs[i]);
908 ASSERT_EQ(status, SUCCESS);
909 }
910 }
911
912 /**
913 * @tc.name: ResultSetMaxSizeTest
914 * @tc.desc: test if kv supports 8 resultSets at the same time
915 * @tc.type: FUNC
916 * @tc.require: I4XVQQ
917 * @tc.author: Yang Qing
918 */
919 HWTEST_F(SingleStoreImplTest, ResultSetMaxSizeTest_Prefix, TestSize.Level0)
920 {
921 ASSERT_NE(kvStore_, nullptr);
922 /**
923 * @tc.steps:step1. Put the entry into the database.
924 * @tc.expected: step1. Returns SUCCESS.
925 */
926 std::vector<Entry> input;
927 for (int i = 0; i < 10; ++i) {
928 Entry entry;
929 entry.key = "k_" + std::to_string(i);
930 entry.value = "v_" + std::to_string(i);
931 input.push_back(entry);
932 }
933 auto status = kvStore_->PutBatch(input);
934 ASSERT_EQ(status, SUCCESS);
935 /**
936 * @tc.steps:step2. Get the resultset.
937 * @tc.expected: step2. Returns SUCCESS.
938 */
939 std::vector<std::shared_ptr<KvStoreResultSet>> outputs(MAX_RESULTSET_SIZE + 1);
940 for (int i = 0; i < MAX_RESULTSET_SIZE; i++) {
941 std::shared_ptr<KvStoreResultSet> output;
942 status = kvStore_->GetResultSet({ "k_i" }, outputs[i]);
943 ASSERT_EQ(status, SUCCESS);
944 }
945 /**
946 * @tc.steps:step3. Get the resultset while resultset size is over the limit.
947 * @tc.expected: step3. Returns OVER_MAX_LIMITS.
948 */
949 status = kvStore_->GetResultSet({ "" }, outputs[MAX_RESULTSET_SIZE]);
950 ASSERT_EQ(status, OVER_MAX_LIMITS);
951 /**
952 * @tc.steps:step4. Close the resultset and getting the resultset is retried
953 * @tc.expected: step4. Returns SUCCESS.
954 */
955 status = kvStore_->CloseResultSet(outputs[0]);
956 ASSERT_EQ(status, SUCCESS);
957 status = kvStore_->GetResultSet({ "" }, outputs[MAX_RESULTSET_SIZE]);
958 ASSERT_EQ(status, SUCCESS);
959
960 for (int i = 1; i <= MAX_RESULTSET_SIZE; i++) {
961 status = kvStore_->CloseResultSet(outputs[i]);
962 ASSERT_EQ(status, SUCCESS);
963 }
964 }
965
966 /**
967 * @tc.name: MaxLogSizeTest
968 * @tc.desc: test if the default max limit of wal is 200MB
969 * @tc.type: FUNC
970 * @tc.require: I4XVQQ
971 * @tc.author: Yang Qing
972 */
973 HWTEST_F(SingleStoreImplTest, MaxLogSizeTest, TestSize.Level0)
974 {
975 ASSERT_NE(kvStore_, nullptr);
976 /**
977 * @tc.steps:step1. Put the random entry into the database.
978 * @tc.expected: step1. Returns SUCCESS.
979 */
980 std::string key;
981 std::vector<uint8_t> value = Random(4 * 1024 * 1024);
982 key = "test0";
983 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
984 key = "test1";
985 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
986 key = "test2";
987 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
988 /**
989 * @tc.steps:step2. Get the resultset.
990 * @tc.expected: step2. Returns SUCCESS.
991 */
992 std::shared_ptr<KvStoreResultSet> output;
993 auto status = kvStore_->GetResultSet({ "" }, output);
994 ASSERT_EQ(status, SUCCESS);
995 ASSERT_NE(output, nullptr);
996 ASSERT_EQ(output->GetCount(), 3);
997 EXPECT_EQ(output->MoveToFirst(), true);
998 /**
999 * @tc.steps:step3. Put more data into the database.
1000 * @tc.expected: step3. Returns SUCCESS.
1001 */
1002 for (int i = 0; i < 50; i++) {
1003 key = "test_" + std::to_string(i);
1004 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1005 }
1006 /**
1007 * @tc.steps:step4. Put more data into the database while the log size is over the limit.
1008 * @tc.expected: step4. Returns LOG_LIMITS_ERROR.
1009 */
1010 key = "test3";
1011 EXPECT_EQ(kvStore_->Put(key, value), WAL_OVER_LIMITS);
1012 EXPECT_EQ(kvStore_->Delete(key), WAL_OVER_LIMITS);
1013 EXPECT_EQ(kvStore_->StartTransaction(), WAL_OVER_LIMITS);
1014 /**
1015 * @tc.steps:step5. Close the resultset and put again.
1016 * @tc.expected: step4. Return SUCCESS.
1017 */
1018
1019 status = kvStore_->CloseResultSet(output);
1020 ASSERT_EQ(status, SUCCESS);
1021 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1022 }
1023
1024 /**
1025 * @tc.name: MaxTest002
1026 * @tc.desc: test if the default max limit of wal is 200MB
1027 * @tc.type: FUNC
1028 * @tc.require: I4XVQQ
1029 * @tc.author: Yang Qing
1030 */
1031 HWTEST_F(SingleStoreImplTest, MaxLogSizeTest002, TestSize.Level0)
1032 {
1033 ASSERT_NE(kvStore_, nullptr);
1034 /**
1035 * @tc.steps:step1. Put the random entry into the database.
1036 * @tc.expected: step1. Returns SUCCESS.
1037 */
1038 std::string key;
1039 std::vector<uint8_t> value = Random(4 * 1024 * 1024);
1040 key = "test0";
1041 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1042 key = "test1";
1043 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1044 key = "test2";
1045 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1046 /**
1047 * @tc.steps:step2. Get the resultset.
1048 * @tc.expected: step2. Returns SUCCESS.
1049 */
1050 std::shared_ptr<KvStoreResultSet> output;
1051 auto status = kvStore_->GetResultSet({ "" }, output);
1052 ASSERT_EQ(status, SUCCESS);
1053 ASSERT_NE(output, nullptr);
1054 ASSERT_EQ(output->GetCount(), 3);
1055 EXPECT_EQ(output->MoveToFirst(), true);
1056 /**
1057 * @tc.steps:step3. Put more data into the database.
1058 * @tc.expected: step3. Returns SUCCESS.
1059 */
1060 for (int i = 0; i < 50; i++) {
1061 key = "test_" + std::to_string(i);
1062 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1063 }
1064 /**
1065 * @tc.steps:step4. Put more data into the database while the log size is over the limit.
1066 * @tc.expected: step4. Returns LOG_LIMITS_ERROR.
1067 */
1068 key = "test3";
1069 EXPECT_EQ(kvStore_->Put(key, value), WAL_OVER_LIMITS);
1070 EXPECT_EQ(kvStore_->Delete(key), WAL_OVER_LIMITS);
1071 EXPECT_EQ(kvStore_->StartTransaction(), WAL_OVER_LIMITS);
1072 status = kvStore_->CloseResultSet(output);
1073 ASSERT_EQ(status, SUCCESS);
1074 /**
1075 * @tc.steps:step5. Close the database and then open the database,put again.
1076 * @tc.expected: step4. Return SUCCESS.
1077 */
1078 AppId appId = { "SingleStoreImplTest" };
1079 StoreId storeId = { "SingleKVStore" };
1080 Options options;
1081 options.kvStoreType = SINGLE_VERSION;
1082 options.securityLevel = S1;
1083 options.encrypt = false;
1084 options.area = EL1;
1085 options.backup = true;
1086 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1087
1088 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1089 ASSERT_EQ(status, SUCCESS);
1090 kvStore_ = nullptr;
1091 kvStore_ = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1092 ASSERT_EQ(status, SUCCESS);
1093
1094 status = kvStore_->GetResultSet({ "" }, output);
1095 ASSERT_EQ(status, SUCCESS);
1096 ASSERT_NE(output, nullptr);
1097 EXPECT_EQ(output->MoveToFirst(), true);
1098
1099 EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
1100 status = kvStore_->CloseResultSet(output);
1101 ASSERT_EQ(status, SUCCESS);
1102 }
1103
1104 /**
1105 * @tc.name: Move_Offset
1106 * @tc.desc: Move the ResultSet Relative Distance
1107 * @tc.type: FUNC
1108 * @tc.require: I4XVQQ
1109 * @tc.author: wu fengshan
1110 */
1111 HWTEST_F(SingleStoreImplTest, Move_Offset, TestSize.Level0)
1112 {
1113 std::vector<Entry> input;
1114 for (int i = 0; i < 10; ++i) {
1115 Entry entry;
1116 entry.key = std::to_string(i).append("_k");
1117 entry.value = std::to_string(i).append("_v");
1118 input.push_back(entry);
1119 }
1120 auto status = kvStore_->PutBatch(input);
1121 ASSERT_EQ(status, SUCCESS);
1122
1123 Key prefix = "2";
1124 std::shared_ptr<KvStoreResultSet> output;
1125 status = kvStore_->GetResultSet(prefix, output);
1126 ASSERT_EQ(status, SUCCESS);
1127 ASSERT_NE(output, nullptr);
1128
1129 auto outputTmp = output;
1130 ASSERT_EQ(outputTmp->Move(1), true);
1131 status = kvStore_->CloseResultSet(output);
1132 ASSERT_EQ(status, SUCCESS);
1133 ASSERT_EQ(output, nullptr);
1134
1135 std::shared_ptr<SingleKvStore> kvStore;
1136 AppId appId = { "SingleStoreImplTest" };
1137 StoreId storeId = { "DeviceKVStore" };
1138 kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
1139 ASSERT_NE(kvStore, nullptr);
1140
1141 status = kvStore->PutBatch(input);
1142 ASSERT_EQ(status, SUCCESS);
1143 std::shared_ptr<KvStoreResultSet> output1;
1144 status = kvStore->GetResultSet(prefix, output1);
1145 ASSERT_EQ(status, SUCCESS);
1146 ASSERT_NE(output1, nullptr);
1147 auto outputTmp1 = output1;
1148 ASSERT_EQ(outputTmp1->Move(1), true);
1149 status = kvStore->CloseResultSet(output1);
1150 ASSERT_EQ(status, SUCCESS);
1151 ASSERT_EQ(output1, nullptr);
1152
1153 kvStore = nullptr;
1154 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1155 ASSERT_EQ(status, SUCCESS);
1156 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1157 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1158 ASSERT_EQ(status, SUCCESS);
1159 }
1160
1161 /**
1162 * @tc.name: GetCount
1163 * @tc.desc: close the result set
1164 * @tc.type: FUNC
1165 * @tc.require: I4XVQQ
1166 * @tc.author: Sven Wang
1167 */
1168 HWTEST_F(SingleStoreImplTest, GetCount, TestSize.Level0)
1169 {
1170 ASSERT_NE(kvStore_, nullptr);
1171 std::vector<Entry> input;
__anon81e1e1f90802(const Key &entry, const Key &sentry) 1172 auto cmp = [](const Key &entry, const Key &sentry) {
1173 return entry.Data() < sentry.Data();
1174 };
1175 std::map<Key, Value, decltype(cmp)> dictionary(cmp);
1176 for (int i = 0; i < 10; ++i) {
1177 Entry entry;
1178 entry.key = std::to_string(i).append("_k");
1179 entry.value = std::to_string(i).append("_v");
1180 dictionary[entry.key] = entry.value;
1181 input.push_back(entry);
1182 }
1183 auto status = kvStore_->PutBatch(input);
1184 ASSERT_EQ(status, SUCCESS);
1185 DataQuery query;
1186 query.InKeys({ "0_k", "1_k" });
1187 int count = 0;
1188 status = kvStore_->GetCount(query, count);
1189 ASSERT_EQ(status, SUCCESS);
1190 ASSERT_EQ(count, 2);
1191 query.Reset();
1192 status = kvStore_->GetCount(query, count);
1193 ASSERT_EQ(status, SUCCESS);
1194 ASSERT_EQ(count, 10);
1195 }
1196
ChangeOwnerToService(std::string baseDir,std::string hashId)1197 void ChangeOwnerToService(std::string baseDir, std::string hashId)
1198 {
1199 static constexpr int ddmsId = 3012;
1200 std::string path = baseDir;
1201 chown(path.c_str(), ddmsId, ddmsId);
1202 path = path + "/kvdb";
1203 chown(path.c_str(), ddmsId, ddmsId);
1204 path = path + "/" + hashId;
1205 chown(path.c_str(), ddmsId, ddmsId);
1206 path = path + "/single_ver";
1207 chown(path.c_str(), ddmsId, ddmsId);
1208 chown((path + "/meta").c_str(), ddmsId, ddmsId);
1209 chown((path + "/cache").c_str(), ddmsId, ddmsId);
1210 path = path + "/main";
1211 chown(path.c_str(), ddmsId, ddmsId);
1212 chown((path + "/gen_natural_store.db").c_str(), ddmsId, ddmsId);
1213 chown((path + "/gen_natural_store.db-shm").c_str(), ddmsId, ddmsId);
1214 chown((path + "/gen_natural_store.db-wal").c_str(), ddmsId, ddmsId);
1215 }
1216
1217 /**
1218 * @tc.name: RemoveDeviceData
1219 * @tc.desc: remove local device data
1220 * @tc.type: FUNC
1221 * @tc.require: I4XVQQ
1222 * @tc.author: Sven Wang
1223 */
1224 HWTEST_F(SingleStoreImplTest, RemoveDeviceData, TestSize.Level0)
1225 {
1226 auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION, false, true);
1227 ASSERT_NE(store, nullptr);
1228 std::vector<Entry> input;
__anon81e1e1f90902(const Key &entry, const Key &sentry) 1229 auto cmp = [](const Key &entry, const Key &sentry) {
1230 return entry.Data() < sentry.Data();
1231 };
1232 std::map<Key, Value, decltype(cmp)> dictionary(cmp);
1233 for (int i = 0; i < 10; ++i) {
1234 Entry entry;
1235 entry.key = std::to_string(i).append("_k");
1236 entry.value = std::to_string(i).append("_v");
1237 dictionary[entry.key] = entry.value;
1238 input.push_back(entry);
1239 }
1240 auto status = store->PutBatch(input);
1241 ASSERT_EQ(status, SUCCESS);
1242 int count = 0;
1243 status = store->GetCount({}, count);
1244 ASSERT_EQ(status, SUCCESS);
1245 ASSERT_EQ(count, 10);
1246 ChangeOwnerToService("/data/service/el1/public/database/SingleStoreImplTest",
1247 "703c6ec99aa7226bb9f6194cdd60e1873ea9ee52faebd55657ade9f5a5cc3cbd");
1248 status = store->RemoveDeviceData(DevManager::GetInstance().GetLocalDevice().networkId);
1249 ASSERT_EQ(status, SUCCESS);
1250 status = store->GetCount({}, count);
1251 ASSERT_EQ(status, SUCCESS);
1252 ASSERT_EQ(count, 10);
1253 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1254 status = StoreManager::GetInstance().Delete({ "SingleStoreImplTest" }, { "DeviceKVStore" }, baseDir);
1255 ASSERT_EQ(status, SUCCESS);
1256 }
1257
1258 /**
1259 * @tc.name: GetSecurityLevel
1260 * @tc.desc: get security level
1261 * @tc.type: FUNC
1262 * @tc.require: I4XVQQ
1263 * @tc.author: Sven Wang
1264 */
1265 HWTEST_F(SingleStoreImplTest, GetSecurityLevel, TestSize.Level0)
1266 {
1267 ASSERT_NE(kvStore_, nullptr);
1268 SecurityLevel securityLevel = NO_LABEL;
1269 auto status = kvStore_->GetSecurityLevel(securityLevel);
1270 ASSERT_EQ(status, SUCCESS);
1271 ASSERT_EQ(securityLevel, S1);
1272 }
1273
1274 /**
1275 * @tc.name: RegisterSyncCallback
1276 * @tc.desc: register the data sync callback
1277 * @tc.type: FUNC
1278 * @tc.require: I4XVQQ
1279 * @tc.author: Sven Wang
1280 */
1281 HWTEST_F(SingleStoreImplTest, RegisterSyncCallback, TestSize.Level0)
1282 {
1283 ASSERT_NE(kvStore_, nullptr);
1284 class TestSyncCallback : public KvStoreSyncCallback {
1285 public:
SyncCompleted(const map<std::string,Status> & results)1286 void SyncCompleted(const map<std::string, Status> &results) override { }
SyncCompleted(const std::map<std::string,Status> & results,uint64_t sequenceId)1287 void SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId) override { }
1288 };
1289 auto callback = std::make_shared<TestSyncCallback>();
1290 auto status = kvStore_->RegisterSyncCallback(callback);
1291 ASSERT_EQ(status, SUCCESS);
1292 }
1293
1294 /**
1295 * @tc.name: UnRegisterSyncCallback
1296 * @tc.desc: unregister the data sync callback
1297 * @tc.type: FUNC
1298 * @tc.require: I4XVQQ
1299 * @tc.author: Sven Wang
1300 */
1301 HWTEST_F(SingleStoreImplTest, UnRegisterSyncCallback, TestSize.Level0)
1302 {
1303 ASSERT_NE(kvStore_, nullptr);
1304 class TestSyncCallback : public KvStoreSyncCallback {
1305 public:
SyncCompleted(const map<std::string,Status> & results)1306 void SyncCompleted(const map<std::string, Status> &results) override { }
SyncCompleted(const std::map<std::string,Status> & results,uint64_t sequenceId)1307 void SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId) override { }
1308 };
1309 auto callback = std::make_shared<TestSyncCallback>();
1310 auto status = kvStore_->RegisterSyncCallback(callback);
1311 ASSERT_EQ(status, SUCCESS);
1312 status = kvStore_->UnRegisterSyncCallback();
1313 ASSERT_EQ(status, SUCCESS);
1314 }
1315
1316 /**
1317 * @tc.name: disableBackup
1318 * @tc.desc: Disable backup
1319 * @tc.type: FUNC
1320 * @tc.require:
1321 * @tc.author: Wang Kai
1322 */
1323 HWTEST_F(SingleStoreImplTest, disableBackup, TestSize.Level0)
1324 {
1325 AppId appId = { "SingleStoreImplTest" };
1326 StoreId storeId = { "SingleKVStoreNoBackup" };
1327 std::shared_ptr<SingleKvStore> kvStoreNoBackup;
1328 kvStoreNoBackup = CreateKVStore(storeId, SINGLE_VERSION, true, false);
1329 ASSERT_NE(kvStoreNoBackup, nullptr);
1330 auto baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1331 auto status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1332 ASSERT_EQ(status, SUCCESS);
1333 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1334 ASSERT_EQ(status, SUCCESS);
1335 }
1336
1337 /**
1338 * @tc.name: PutOverMaxValue
1339 * @tc.desc: put key-value data to the kv store and the value size over the limits
1340 * @tc.type: FUNC
1341 * @tc.require: I605H3
1342 * @tc.author: Wang Kai
1343 */
1344 HWTEST_F(SingleStoreImplTest, PutOverMaxValue, TestSize.Level0)
1345 {
1346 ASSERT_NE(kvStore_, nullptr);
1347 std::string value;
1348 int maxsize = 1024 * 1024;
1349 for (int i = 0; i <= maxsize; i++) {
1350 value += "test";
1351 }
1352 Value valuePut(value);
1353 auto status = kvStore_->Put({ "Put Test" }, valuePut);
1354 ASSERT_EQ(status, INVALID_ARGUMENT);
1355 }
1356 /**
1357 * @tc.name: DeleteOverMaxKey
1358 * @tc.desc: delete the values of the keys and the key size over the limits
1359 * @tc.type: FUNC
1360 * @tc.require: I605H3
1361 * @tc.author: Wang Kai
1362 */
1363 HWTEST_F(SingleStoreImplTest, DeleteOverMaxKey, TestSize.Level0)
1364 {
1365 ASSERT_NE(kvStore_, nullptr);
1366 std::string str;
1367 int maxsize = 1024;
1368 for (int i = 0; i <= maxsize; i++) {
1369 str += "key";
1370 }
1371 Key key(str);
1372 auto status = kvStore_->Put(key, "Put Test");
1373 ASSERT_EQ(status, INVALID_ARGUMENT);
1374 Value value;
1375 status = kvStore_->Get(key, value);
1376 ASSERT_EQ(status, INVALID_ARGUMENT);
1377 status = kvStore_->Delete(key);
1378 ASSERT_EQ(status, INVALID_ARGUMENT);
1379 }
1380
1381 /**
1382 * @tc.name: GetEntriesOverMaxKey
1383 * @tc.desc: get entries the by prefix and the prefix size over the limits
1384 * @tc.type: FUNC
1385 * @tc.require: I605H3
1386 * @tc.author: Wang Kai
1387 */
1388 HWTEST_F(SingleStoreImplTest, GetEntriesOverMaxPrefix, TestSize.Level0)
1389 {
1390 ASSERT_NE(kvStore_, nullptr);
1391 std::string str;
1392 int maxsize = 1024;
1393 for (int i = 0; i <= maxsize; i++) {
1394 str += "key";
1395 }
1396 const Key prefix(str);
1397 std::vector<Entry> output;
1398 auto status = kvStore_->GetEntries(prefix, output);
1399 ASSERT_EQ(status, INVALID_ARGUMENT);
1400 }
1401
1402 /**
1403 * @tc.name: GetResultSetOverMaxPrefix
1404 * @tc.desc: get result set the by prefix and the prefix size over the limits
1405 * @tc.type: FUNC
1406 * @tc.require: I605H3
1407 * @tc.author: Wang Kai
1408 */
1409 HWTEST_F(SingleStoreImplTest, GetResultSetOverMaxPrefix, TestSize.Level0)
1410 {
1411 ASSERT_NE(kvStore_, nullptr);
1412 std::string str;
1413 int maxsize = 1024;
1414 for (int i = 0; i <= maxsize; i++) {
1415 str += "key";
1416 }
1417 const Key prefix(str);
1418 std::shared_ptr<KvStoreResultSet> output;
1419 auto status = kvStore_->GetResultSet(prefix, output);
1420 ASSERT_EQ(status, INVALID_ARGUMENT);
1421 }
1422
1423 /**
1424 * @tc.name: RemoveNullDeviceData
1425 * @tc.desc: remove local device data and the device is null
1426 * @tc.type: FUNC
1427 * @tc.require: I605H3
1428 * @tc.author: Wang Kai
1429 */
1430 HWTEST_F(SingleStoreImplTest, RemoveNullDeviceData, TestSize.Level0)
1431 {
1432 auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION, false, true);
1433 ASSERT_NE(store, nullptr);
1434 std::vector<Entry> input;
__anon81e1e1f90a02(const Key &entry, const Key &sentry) 1435 auto cmp = [](const Key &entry, const Key &sentry) {
1436 return entry.Data() < sentry.Data();
1437 };
1438 std::map<Key, Value, decltype(cmp)> dictionary(cmp);
1439 for (int i = 0; i < 10; ++i) {
1440 Entry entry;
1441 entry.key = std::to_string(i).append("_k");
1442 entry.value = std::to_string(i).append("_v");
1443 dictionary[entry.key] = entry.value;
1444 input.push_back(entry);
1445 }
1446 auto status = store->PutBatch(input);
1447 ASSERT_EQ(status, SUCCESS);
1448 int count = 0;
1449 status = store->GetCount({}, count);
1450 ASSERT_EQ(status, SUCCESS);
1451 ASSERT_EQ(count, 10);
1452 const string device = { "" };
1453 ChangeOwnerToService("/data/service/el1/public/database/SingleStoreImplTest",
1454 "703c6ec99aa7226bb9f6194cdd60e1873ea9ee52faebd55657ade9f5a5cc3cbd");
1455 status = store->RemoveDeviceData(device);
1456 ASSERT_EQ(status, SUCCESS);
1457 }
1458
1459 /**
1460 * @tc.name: CloseKVStoreWithInvalidAppId
1461 * @tc.desc: close the kv store with invalid appid
1462 * @tc.type: FUNC
1463 * @tc.require:
1464 * @tc.author: Yang Qing
1465 */
1466 HWTEST_F(SingleStoreImplTest, CloseKVStoreWithInvalidAppId, TestSize.Level0)
1467 {
1468 AppId appId = { "" };
1469 StoreId storeId = { "SingleKVStore" };
1470 Status status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1471 ASSERT_EQ(status, INVALID_ARGUMENT);
1472 }
1473
1474 /**
1475 * @tc.name: CloseKVStoreWithInvalidStoreId
1476 * @tc.desc: close the kv store with invalid store id
1477 * @tc.type: FUNC
1478 * @tc.require:
1479 * @tc.author: Yang Qing
1480 */
1481 HWTEST_F(SingleStoreImplTest, CloseKVStoreWithInvalidStoreId, TestSize.Level0)
1482 {
1483 AppId appId = { "SingleStoreImplTest" };
1484 StoreId storeId = { "" };
1485 Status status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1486 ASSERT_EQ(status, INVALID_ARGUMENT);
1487 }
1488
1489 /**
1490 * @tc.name: CloseAllKVStore
1491 * @tc.desc: close all kv store
1492 * @tc.type: FUNC
1493 * @tc.require:
1494 * @tc.author: Yang Qing
1495 */
1496 HWTEST_F(SingleStoreImplTest, CloseAllKVStore, TestSize.Level0)
1497 {
1498 AppId appId = { "SingleStoreImplTestCloseAll" };
1499 std::vector<std::shared_ptr<SingleKvStore>> kvStores;
1500 for (int i = 0; i < 5; i++) {
1501 std::shared_ptr<SingleKvStore> kvStore;
1502 Options options;
1503 options.kvStoreType = SINGLE_VERSION;
1504 options.securityLevel = S1;
1505 options.area = EL1;
1506 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1507 std::string sId = "SingleStoreImplTestCloseAll" + std::to_string(i);
1508 StoreId storeId = { sId };
1509 Status status;
1510 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1511 ASSERT_NE(kvStore, nullptr);
1512 kvStores.push_back(kvStore);
1513 ASSERT_EQ(status, SUCCESS);
1514 kvStore = nullptr;
1515 }
1516 Status status = StoreManager::GetInstance().CloseAllKVStore(appId);
1517 ASSERT_EQ(status, SUCCESS);
1518 }
1519
1520 /**
1521 * @tc.name: CloseAllKVStoreWithInvalidAppId
1522 * @tc.desc: close the kv store with invalid appid
1523 * @tc.type: FUNC
1524 * @tc.require:
1525 * @tc.author: Yang Qing
1526 */
1527 HWTEST_F(SingleStoreImplTest, CloseAllKVStoreWithInvalidAppId, TestSize.Level0)
1528 {
1529 AppId appId = { "" };
1530 Status status = StoreManager::GetInstance().CloseAllKVStore(appId);
1531 ASSERT_EQ(status, INVALID_ARGUMENT);
1532 }
1533
1534 /**
1535 * @tc.name: DeleteWithInvalidAppId
1536 * @tc.desc: delete the kv store with invalid appid
1537 * @tc.type: FUNC
1538 * @tc.require:
1539 * @tc.author: Yang Qing
1540 */
1541 HWTEST_F(SingleStoreImplTest, DeleteWithInvalidAppId, TestSize.Level0)
1542 {
1543 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1544 AppId appId = { "" };
1545 StoreId storeId = { "SingleKVStore" };
1546 Status status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1547 ASSERT_EQ(status, INVALID_ARGUMENT);
1548 }
1549
1550 /**
1551 * @tc.name: DeleteWithInvalidStoreId
1552 * @tc.desc: delete the kv store with invalid storeid
1553 * @tc.type: FUNC
1554 * @tc.require:
1555 * @tc.author: Yang Qing
1556 */
1557 HWTEST_F(SingleStoreImplTest, DeleteWithInvalidStoreId, TestSize.Level0)
1558 {
1559 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1560 AppId appId = { "SingleStoreImplTest" };
1561 StoreId storeId = { "" };
1562 Status status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1563 ASSERT_EQ(status, INVALID_ARGUMENT);
1564 }
1565
1566 /**
1567 * @tc.name: GetKVStoreWithPersistentFalse
1568 * @tc.desc: delete the kv store with the persistent is false
1569 * @tc.type: FUNC
1570 * @tc.require:
1571 * @tc.author: Wang Kai
1572 */
1573 HWTEST_F(SingleStoreImplTest, GetKVStoreWithPersistentFalse, TestSize.Level0)
1574 {
1575 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1576 AppId appId = { "SingleStoreImplTest" };
1577 StoreId storeId = { "SingleKVStorePersistentFalse" };
1578 std::shared_ptr<SingleKvStore> kvStore;
1579 Options options;
1580 options.kvStoreType = SINGLE_VERSION;
1581 options.securityLevel = S1;
1582 options.area = EL1;
1583 options.persistent = false;
1584 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1585 Status status;
1586 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1587 ASSERT_EQ(kvStore, nullptr);
1588 }
1589
1590 /**
1591 * @tc.name: GetKVStoreWithInvalidType
1592 * @tc.desc: delete the kv store with the KvStoreType is InvalidType
1593 * @tc.type: FUNC
1594 * @tc.require:
1595 * @tc.author: Wang Kai
1596 */
1597 HWTEST_F(SingleStoreImplTest, GetKVStoreWithInvalidType, TestSize.Level0)
1598 {
1599 std::string baseDir = "/data/service/el1/public/database/SingleStoreImpStore";
1600 AppId appId = { "SingleStoreImplTest" };
1601 StoreId storeId = { "SingleKVStoreInvalidType" };
1602 std::shared_ptr<SingleKvStore> kvStore;
1603 Options options;
1604 options.kvStoreType = INVALID_TYPE;
1605 options.securityLevel = S1;
1606 options.area = EL1;
1607 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1608 Status status;
1609 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1610 ASSERT_EQ(kvStore, nullptr);
1611 }
1612
1613 /**
1614 * @tc.name: GetKVStoreWithCreateIfMissingFalse
1615 * @tc.desc: delete the kv store with the createIfMissing is false
1616 * @tc.type: FUNC
1617 * @tc.require:
1618 * @tc.author: Wang Kai
1619 */
1620 HWTEST_F(SingleStoreImplTest, GetKVStoreWithCreateIfMissingFalse, TestSize.Level0)
1621 {
1622 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1623 AppId appId = { "SingleStoreImplTest" };
1624 StoreId storeId = { "SingleKVStoreCreateIfMissingFalse" };
1625 std::shared_ptr<SingleKvStore> kvStore;
1626 Options options;
1627 options.kvStoreType = SINGLE_VERSION;
1628 options.securityLevel = S1;
1629 options.area = EL1;
1630 options.createIfMissing = false;
1631 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1632 Status status;
1633 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1634 ASSERT_EQ(kvStore, nullptr);
1635 }
1636
1637 /**
1638 * @tc.name: GetKVStoreWithAutoSync
1639 * @tc.desc: delete the kv store with the autoSync is false
1640 * @tc.type: FUNC
1641 * @tc.require:
1642 * @tc.author: Wang Kai
1643 */
1644 HWTEST_F(SingleStoreImplTest, GetKVStoreWithAutoSync, TestSize.Level0)
1645 {
1646 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1647 AppId appId = { "SingleStoreImplTest" };
1648 StoreId storeId = { "SingleKVStoreAutoSync" };
1649 std::shared_ptr<SingleKvStore> kvStore;
1650 Options options;
1651 options.kvStoreType = SINGLE_VERSION;
1652 options.securityLevel = S1;
1653 options.area = EL1;
1654 options.autoSync = false;
1655 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1656 Status status;
1657 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1658 ASSERT_NE(kvStore, nullptr);
1659 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1660 ASSERT_EQ(status, SUCCESS);
1661 }
1662
1663 /**
1664 * @tc.name: GetKVStoreWithAreaEL2
1665 * @tc.desc: delete the kv store with the area is EL2
1666 * @tc.type: FUNC
1667 * @tc.require:
1668 * @tc.author: Wang Kai
1669 */
1670 HWTEST_F(SingleStoreImplTest, GetKVStoreWithAreaEL2, TestSize.Level0)
1671 {
1672 std::string baseDir = "/data/service/el2/100/SingleStoreImplTest";
1673 mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
1674
1675 AppId appId = { "SingleStoreImplTest" };
1676 StoreId storeId = { "SingleKVStoreAreaEL2" };
1677 std::shared_ptr<SingleKvStore> kvStore;
1678 Options options;
1679 options.kvStoreType = SINGLE_VERSION;
1680 options.securityLevel = S2;
1681 options.area = EL2;
1682 options.baseDir = "/data/service/el2/100/SingleStoreImplTest";
1683 Status status;
1684 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1685 ASSERT_NE(kvStore, nullptr);
1686 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1687 ASSERT_EQ(status, SUCCESS);
1688 }
1689
1690 /**
1691 * @tc.name: GetKVStoreWithRebuildTrue
1692 * @tc.desc: delete the kv store with the rebuild is true
1693 * @tc.type: FUNC
1694 * @tc.require:
1695 * @tc.author: Wang Kai
1696 */
1697 HWTEST_F(SingleStoreImplTest, GetKVStoreWithRebuildTrue, TestSize.Level0)
1698 {
1699 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1700 AppId appId = { "SingleStoreImplTest" };
1701 StoreId storeId = { "SingleKVStoreRebuildFalse" };
1702 std::shared_ptr<SingleKvStore> kvStore;
1703 Options options;
1704 options.kvStoreType = SINGLE_VERSION;
1705 options.securityLevel = S1;
1706 options.area = EL1;
1707 options.rebuild = true;
1708 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1709 Status status;
1710 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1711 ASSERT_NE(kvStore, nullptr);
1712 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1713 ASSERT_EQ(status, SUCCESS);
1714 }
1715
1716 /**
1717 * @tc.name: GetStaticStore
1718 * @tc.desc: get static store
1719 * @tc.type: FUNC
1720 * @tc.require:
1721 * @tc.author: zuojiangijang
1722 */
1723 HWTEST_F(SingleStoreImplTest, GetStaticStore, TestSize.Level0)
1724 {
1725 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1726 AppId appId = { "SingleStoreImplTest" };
1727 StoreId storeId = { "StaticStoreTest" };
1728 std::shared_ptr<SingleKvStore> kvStore;
1729 Options options;
1730 options.kvStoreType = SINGLE_VERSION;
1731 options.securityLevel = S1;
1732 options.area = EL1;
1733 options.rebuild = true;
1734 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1735 options.dataType = DataType::TYPE_STATICS;
1736 Status status;
1737 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1738 ASSERT_NE(kvStore, nullptr);
1739 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1740 ASSERT_EQ(status, SUCCESS);
1741 }
1742
1743 /**
1744 * @tc.name: StaticStoreAsyncGet
1745 * @tc.desc: static store async get
1746 * @tc.type: FUNC
1747 * @tc.require:
1748 * @tc.author: zuojiangijang
1749 */
1750 HWTEST_F(SingleStoreImplTest, StaticStoreAsyncGet, TestSize.Level0)
1751 {
1752 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1753 AppId appId = { "SingleStoreImplTest" };
1754 StoreId storeId = { "StaticStoreAsyncGetTest" };
1755 std::shared_ptr<SingleKvStore> kvStore;
1756 Options options;
1757 options.kvStoreType = SINGLE_VERSION;
1758 options.securityLevel = S1;
1759 options.area = EL1;
1760 options.rebuild = true;
1761 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1762 options.dataType = DataType::TYPE_STATICS;
1763 Status status;
1764 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1765 ASSERT_NE(kvStore, nullptr);
1766 BlockData<bool> blockData { 1, false };
__anon81e1e1f90b02(Status status, Value &&value) 1767 std::function<void(Status, Value &&)> result = [&blockData](Status status, Value &&value) {
1768 ASSERT_EQ(status, Status::NOT_FOUND);
1769 blockData.SetValue(true);
1770 };
1771 auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1772 kvStore->Get({ "key" }, networkId, result);
1773 blockData.GetValue();
1774 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1775 ASSERT_EQ(status, SUCCESS);
1776 }
1777
1778 /**
1779 * @tc.name: StaticStoreAsyncGetEntries
1780 * @tc.desc: static store async get entries
1781 * @tc.type: FUNC
1782 * @tc.require:
1783 * @tc.author: zuojiangijang
1784 */
1785 HWTEST_F(SingleStoreImplTest, StaticStoreAsyncGetEntries, TestSize.Level0)
1786 {
1787 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1788 AppId appId = { "SingleStoreImplTest" };
1789 StoreId storeId = { "StaticStoreAsyncGetEntriesTest" };
1790 std::shared_ptr<SingleKvStore> kvStore;
1791 Options options;
1792 options.kvStoreType = SINGLE_VERSION;
1793 options.securityLevel = S1;
1794 options.area = EL1;
1795 options.rebuild = true;
1796 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1797 options.dataType = DataType::TYPE_STATICS;
1798 Status status;
1799 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1800 ASSERT_NE(kvStore, nullptr);
1801 BlockData<bool> blockData { 1, false };
1802 std::function<void(Status, std::vector<Entry> &&)> result = [&blockData](
__anon81e1e1f90c02( Status status, std::vector<Entry> &&value) 1803 Status status, std::vector<Entry> &&value) {
1804 ASSERT_EQ(status, Status::SUCCESS);
1805 blockData.SetValue(true);
1806 };
1807 auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1808 kvStore->GetEntries({ "key" }, networkId, result);
1809 blockData.GetValue();
1810 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1811 ASSERT_EQ(status, SUCCESS);
1812 }
1813
1814 /**
1815 * @tc.name: DynamicStoreAsyncGet
1816 * @tc.desc: dynamic store async get
1817 * @tc.type: FUNC
1818 * @tc.require:
1819 * @tc.author: zuojiangijang
1820 */
1821 HWTEST_F(SingleStoreImplTest, DynamicStoreAsyncGet, TestSize.Level0)
1822 {
1823 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1824 AppId appId = { "SingleStoreImplTest" };
1825 StoreId storeId = { "DynamicStoreAsyncGetTest" };
1826 std::shared_ptr<SingleKvStore> kvStore;
1827 Options options;
1828 options.kvStoreType = SINGLE_VERSION;
1829 options.securityLevel = S1;
1830 options.area = EL1;
1831 options.rebuild = true;
1832 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1833 options.dataType = DataType::TYPE_DYNAMICAL;
1834 Status status;
1835 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1836 ASSERT_NE(kvStore, nullptr);
1837 status = kvStore->Put({ "Put Test" }, { "Put Value" });
1838 auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1839 BlockData<bool> blockData { 1, false };
__anon81e1e1f90d02(Status status, Value &&value) 1840 std::function<void(Status, Value &&)> result = [&blockData](Status status, Value &&value) {
1841 ASSERT_EQ(status, Status::SUCCESS);
1842 ASSERT_EQ(value.ToString(), "Put Value");
1843 blockData.SetValue(true);
1844 };
1845 kvStore->Get({ "Put Test" }, networkId, result);
1846 blockData.GetValue();
1847 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1848 ASSERT_EQ(status, SUCCESS);
1849 }
1850
1851 /**
1852 * @tc.name: DynamicStoreAsyncGetEntries
1853 * @tc.desc: dynamic store async get entries
1854 * @tc.type: FUNC
1855 * @tc.require:
1856 * @tc.author: zuojiangijang
1857 */
1858 HWTEST_F(SingleStoreImplTest, DynamicStoreAsyncGetEntries, TestSize.Level0)
1859 {
1860 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1861 AppId appId = { "SingleStoreImplTest" };
1862 StoreId storeId = { "DynamicStoreAsyncGetEntriesTest" };
1863 std::shared_ptr<SingleKvStore> kvStore;
1864 Options options;
1865 options.kvStoreType = SINGLE_VERSION;
1866 options.securityLevel = S1;
1867 options.area = EL1;
1868 options.rebuild = true;
1869 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1870 options.dataType = DataType::TYPE_DYNAMICAL;
1871 Status status;
1872 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1873 ASSERT_NE(kvStore, nullptr);
1874 std::vector<Entry> entries;
1875 for (int i = 0; i < 10; ++i) {
1876 Entry entry;
1877 entry.key = "key_" + std::to_string(i);
1878 entry.value = std::to_string(i);
1879 entries.push_back(entry);
1880 }
1881 status = kvStore->PutBatch(entries);
1882 ASSERT_EQ(status, SUCCESS);
1883 auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1884 BlockData<bool> blockData { 1, false };
1885 std::function<void(Status, std::vector<Entry> &&)> result = [entries, &blockData](
__anon81e1e1f90e02( Status status, std::vector<Entry> &&value) 1886 Status status, std::vector<Entry> &&value) {
1887 ASSERT_EQ(status, Status::SUCCESS);
1888 ASSERT_EQ(value.size(), entries.size());
1889 blockData.SetValue(true);
1890 };
1891 kvStore->GetEntries({ "key_" }, networkId, result);
1892 blockData.GetValue();
1893 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1894 ASSERT_EQ(status, SUCCESS);
1895 }
1896
1897 /**
1898 * @tc.name: SetConfig
1899 * @tc.desc: SetConfig
1900 * @tc.type: FUNC
1901 * @tc.require:
1902 * @tc.author: ht
1903 */
1904 HWTEST_F(SingleStoreImplTest, SetConfig, TestSize.Level0)
1905 {
1906 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1907 AppId appId = { "SingleStoreImplTest" };
1908 StoreId storeId = { "SetConfigTest" };
1909 std::shared_ptr<SingleKvStore> kvStore;
1910 Options options;
1911 options.kvStoreType = SINGLE_VERSION;
1912 options.securityLevel = S1;
1913 options.area = EL1;
1914 options.rebuild = true;
1915 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1916 options.dataType = DataType::TYPE_DYNAMICAL;
1917 options.cloudConfig.enableCloud = false;
1918 Status status;
1919 kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1920 ASSERT_NE(kvStore, nullptr);
1921 StoreConfig storeConfig;
1922 storeConfig.cloudConfig.enableCloud = true;
1923 ASSERT_EQ(kvStore->SetConfig(storeConfig), Status::SUCCESS);
1924 }
1925
1926 /**
1927 * @tc.name: GetDeviceEntries001
1928 * @tc.desc:
1929 * @tc.type: FUNC
1930 */
1931 HWTEST_F(SingleStoreImplTest, GetDeviceEntries001, TestSize.Level1)
1932 {
1933 std::string pkgNameEx = "_distributed_data";
1934 std::shared_ptr<SingleStoreImpl> kvStore;
1935 kvStore = CreateKVStore();
1936 ASSERT_NE(kvStore, nullptr);
1937 std::vector<Entry> output;
1938 std::string device = DevManager::GetInstance().GetUnEncryptedUuid();
1939 std::string devices = "GetDeviceEntriestest";
1940 auto status = kvStore->GetDeviceEntries("", output);
1941 ASSERT_EQ(status, INVALID_ARGUMENT);
1942 status = kvStore->GetDeviceEntries(device, output);
1943 ASSERT_EQ(status, SUCCESS);
1944 DevInfo devinfo;
1945 std::string pkgName = std::to_string(getpid()) + pkgNameEx;
1946 DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(pkgName, devinfo);
1947 ASSERT_NE(std::string(devinfo.deviceId), "");
1948 status = kvStore->GetDeviceEntries(std::string(devinfo.deviceId), output);
1949 ASSERT_EQ(status, SUCCESS);
1950 }
1951
1952 /**
1953 * @tc.name: DoSync001
1954 * @tc.desc: observer = nullptr
1955 * @tc.type: FUNC
1956 */
1957 HWTEST_F(SingleStoreImplTest, DoSync001, TestSize.Level1)
1958 {
1959 std::shared_ptr<SingleStoreImpl> kvStore;
1960 kvStore = CreateKVStore();
1961 EXPECT_NE(kvStore, nullptr) << "kvStorePtr is null.";
1962 std::string deviceId = "no_exist_device_id";
1963 std::vector<std::string> deviceIds = { deviceId };
1964 uint32_t allowedDelayMs = 200;
1965 kvStore->isClientSync_ = false;
1966 auto syncStatus = kvStore->Sync(deviceIds, SyncMode::PUSH, allowedDelayMs);
1967 EXPECT_EQ(syncStatus, Status::SUCCESS) << "sync device should return success";
1968 kvStore->isClientSync_ = true;
1969 kvStore->syncObserver_ = nullptr;
1970 syncStatus = kvStore->Sync(deviceIds, SyncMode::PUSH, allowedDelayMs);
1971 EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should return error";
1972 }
1973
1974 /**
1975 * @tc.name: SetCapabilityEnabled001
1976 * @tc.desc: enabled
1977 * @tc.type: FUNC
1978 */
1979 HWTEST_F(SingleStoreImplTest, SetCapabilityEnabled001, TestSize.Level1)
1980 {
1981 ASSERT_NE(kvStore_, nullptr);
1982 auto status = kvStore_->SetCapabilityEnabled(true);
1983 ASSERT_EQ(status, SUCCESS);
1984 status = kvStore_->SetCapabilityEnabled(false);
1985 ASSERT_EQ(status, SUCCESS);
1986 }
1987
1988 /**
1989 * @tc.name: DoClientSync001
1990 * @tc.desc: observer = nullptr
1991 * @tc.type: FUNC
1992 */
1993 HWTEST_F(SingleStoreImplTest, DoClientSync001, TestSize.Level1)
1994 {
1995 std::shared_ptr<SingleStoreImpl> kvStore;
1996 kvStore = CreateKVStore();
1997 ASSERT_NE(kvStore, nullptr);
1998 KVDBService::SyncInfo syncInfo;
1999 syncInfo.mode = SyncMode::PULL;
2000 syncInfo.seqId = 10; // syncInfo seqId
2001 syncInfo.devices = { "networkId" };
2002 std::shared_ptr<SyncCallback> observer;
2003 observer = nullptr;
2004 auto status = kvStore->DoClientSync(syncInfo, observer);
2005 ASSERT_EQ(status, DB_ERROR);
2006 }
2007
2008 /**
2009 * @tc.name: DoNotifyChange001
2010 * @tc.desc: called within timeout
2011 * @tc.type: FUNC
2012 */
2013 HWTEST_F(SingleStoreImplTest, DoNotifyChange001, TestSize.Level1)
2014 {
2015 std::shared_ptr<SingleStoreImpl> kvStore;
2016 kvStore = CreateKVStore();
2017 EXPECT_NE(kvStore, nullptr) << "kvStorePtr is null.";
2018 auto status = kvStore->Put({ "Put Test" }, { "Put Value" });
2019 ASSERT_EQ(kvStore->notifyExpiredTime_, 0);
2020 kvStore->cloudAutoSync_ = true;
2021 status = kvStore->Put({ "Put Test" }, { "Put Value" });
2022 ASSERT_EQ(status, SUCCESS);
2023 auto notifyExpiredTime = kvStore->notifyExpiredTime_;
2024 ASSERT_NE(notifyExpiredTime, 0);
2025 status = kvStore->Put({ "Put Test1" }, { "Put Value1" });
2026 ASSERT_EQ(status, SUCCESS);
2027 ASSERT_EQ(notifyExpiredTime, kvStore->notifyExpiredTime_);
2028 sleep(1);
2029 status = kvStore->Put({ "Put Test2" }, { "Put Value2" });
2030 ASSERT_EQ(status, SUCCESS);
2031 ASSERT_NE(notifyExpiredTime, kvStore->notifyExpiredTime_);
2032 }
2033
2034 /**
2035 * @tc.name: DoAutoSync001
2036 * @tc.desc: observer = nullptr
2037 * @tc.type: FUNC
2038 */
2039 HWTEST_F(SingleStoreImplTest, DoAutoSync001, TestSize.Level1)
2040 {
2041 std::shared_ptr<SingleStoreImpl> kvStore;
2042 kvStore = CreateKVStore(true);
2043 ASSERT_NE(kvStore, nullptr);
2044 kvStore->isApplication_ = true;
2045 auto status = kvStore->Put({ "Put Test" }, { "Put Value" });
2046 ASSERT_EQ(status, SUCCESS);
2047 ASSERT_EQ(!kvStore->autoSync_ || !kvStore->isApplication_, false);
2048 }
2049
2050 /**
2051 * @tc.name: IsRemoteChanged
2052 * @tc.desc: is remote changed
2053 * @tc.type: FUNC
2054 */
2055 HWTEST_F(SingleStoreImplTest, IsRemoteChanged, TestSize.Level0)
2056 {
2057 std::shared_ptr<SingleStoreImpl> kvStore;
2058 kvStore = CreateKVStore();
2059 ASSERT_NE(kvStore, nullptr);
2060 bool ret = kvStore->IsRemoteChanged("");
2061 ASSERT_TRUE(ret);
2062 }
2063
2064 /**
2065 * @tc.name: ReportDBFaultEvent
2066 * @tc.desc: report DB corrupted fault
2067 * @tc.type: FUNC
2068 */
2069 HWTEST_F(SingleStoreImplTest, ReportDBFaultEvent, TestSize.Level0)
2070 {
2071 std::shared_ptr<SingleStoreImpl> kvStore;
2072 kvStore = CreateKVStore();
2073 ASSERT_NE(kvStore, nullptr);
2074 Status status = DATA_CORRUPTED;
2075 kvStore->ReportDBFaultEvent(status, std::string(__FUNCTION__));
2076 EXPECT_TRUE(status == DATA_CORRUPTED);
2077 }
2078 } // namespace OHOS::Test