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
16 #include <gtest/gtest.h>
17 #include <unistd.h>
18 #include <cstddef>
19 #include <cstdint>
20 #include <vector>
21 #include "dev_manager.h"
22 #include "distributed_kv_data_manager.h"
23 #include "file_ex.h"
24 #include "types.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::DistributedKv;
28
29 class DeviceKvStoreTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32
33 static void TearDownTestCase(void);
34
35 void SetUp();
36
37 void TearDown();
38 static std::string GetKey(const std::string &key);
39
40 static std::shared_ptr<SingleKvStore> kvStore_; // declare kvstore instance.
41 static Status status_;
42 static std::string deviceId_;
43 static Options options_;
44 static const int MAX_VALUE_SIZE = 4 * 1024 * 1024; // max value size is 4M.;
45 };
46
47 const std::string VALID_SCHEMA = "{\"SCHEMA_VERSION\":\"1.0\","
48 "\"SCHEMA_MODE\":\"STRICT\","
49 "\"SCHEMA_SKIPSIZE\":0,"
50 "\"SCHEMA_DEFINE\":{"
51 "\"age\":\"INTEGER, NOT NULL\""
52 "},"
53 "\"SCHEMA_INDEXES\":[\"$.age\"]}";
54
55 std::shared_ptr<SingleKvStore> DeviceKvStoreTest::kvStore_ = nullptr;
56 Status DeviceKvStoreTest::status_ = Status::ERROR;
57 std::string DeviceKvStoreTest::deviceId_;
58 Options DeviceKvStoreTest::options_;
59
SetUpTestCase(void)60 void DeviceKvStoreTest::SetUpTestCase(void)
61 {
62 OHOS::SaveStringToFile("/sys/fs/selinux/enforce", "0");
63 DistributedKvDataManager manager;
64 options_.area = EL1;
65 options_.baseDir = std::string("/data/service/el1/public/database/odmf");
66 mkdir(options_.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
67 AppId appId = { "odmf" };
68 StoreId storeId = { "student_device" }; // define kvstore(database) name.
69 // [create and] open and initialize kvstore instance.
70 status_ = manager.GetSingleKvStore(options_, appId, storeId, kvStore_);
71 auto deviceInfo = DevManager::GetInstance().GetLocalDevice();
72 deviceId_ = deviceInfo.networkId;
73 }
74
TearDownTestCase(void)75 void DeviceKvStoreTest::TearDownTestCase(void)
76 {
77 OHOS::SaveStringToFile("/sys/fs/selinux/enforce", "1");
78 DistributedKvDataManager manager;
79 AppId appId = { "odmf" };
80 manager.DeleteAllKvStore(appId, options_.baseDir);
81 (void)remove("/data/service/el1/public/database/odmf/key");
82 (void)remove("/data/service/el1/public/database/odmf/kvdb");
83 (void)remove("/data/service/el1/public/database/odmf");
84 }
85
SetUp(void)86 void DeviceKvStoreTest::SetUp(void)
87 {}
88
TearDown(void)89 void DeviceKvStoreTest::TearDown(void)
90 {}
91
GetKey(const std::string & key)92 std::string DeviceKvStoreTest::GetKey(const std::string& key)
93 {
94 std::ostringstream oss;
95 oss << std::setfill('0') << std::setw(sizeof(uint32_t)) << deviceId_.length();
96 oss << deviceId_ << std::string(key.begin(), key.end());
97 return oss.str();
98 }
99
100 class DeviceObserverTestImpl : public KvStoreObserver {
101 public:
102 std::vector<Entry> insertEntries_;
103 std::vector<Entry> updateEntries_;
104 std::vector<Entry> deleteEntries_;
105 bool isClear_ = false;
106 DeviceObserverTestImpl();
~DeviceObserverTestImpl()107 ~DeviceObserverTestImpl()
108 {}
109
110 DeviceObserverTestImpl(const DeviceObserverTestImpl &) = delete;
111 DeviceObserverTestImpl &operator=(const DeviceObserverTestImpl &) = delete;
112 DeviceObserverTestImpl(DeviceObserverTestImpl &&) = delete;
113 DeviceObserverTestImpl &operator=(DeviceObserverTestImpl &&) = delete;
114
115 void OnChange(const ChangeNotification &changeNotification);
116
117 // reset the callCount_ to zero.
118 void ResetToZero();
119
120 uint64_t GetCallCount() const;
121
122 private:
123 uint64_t callCount_ = 0;
124 };
125
OnChange(const ChangeNotification & changeNotification)126 void DeviceObserverTestImpl::OnChange(const ChangeNotification &changeNotification)
127 {
128 callCount_++;
129 insertEntries_ = changeNotification.GetInsertEntries();
130 updateEntries_ = changeNotification.GetUpdateEntries();
131 deleteEntries_ = changeNotification.GetDeleteEntries();
132 isClear_ = changeNotification.IsClear();
133 }
134
DeviceObserverTestImpl()135 DeviceObserverTestImpl::DeviceObserverTestImpl()
136 {
137 }
138
ResetToZero()139 void DeviceObserverTestImpl::ResetToZero()
140 {
141 callCount_ = 0;
142 }
143
GetCallCount() const144 uint64_t DeviceObserverTestImpl::GetCallCount() const
145 {
146 return callCount_;
147 }
148
149 class DeviceSyncCallbackTestImpl : public KvStoreSyncCallback {
150 public:
151 void SyncCompleted(const std::map<std::string, Status> &results);
152 };
153
SyncCompleted(const std::map<std::string,Status> & results)154 void DeviceSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Status> &results)
155 {}
156
157 /**
158 * @tc.name: GetStoreId001
159 * @tc.desc: Get a Device KvStore instance.
160 * @tc.type: FUNC
161 * @tc.require: I5DE2A
162 * @tc.author: Sven Wang
163 */
164 HWTEST_F(DeviceKvStoreTest, GetStoreId001, TestSize.Level1)
165 {
166 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
167
168 auto storID = kvStore_->GetStoreId();
169 EXPECT_EQ(storID.storeId, "student_device");
170 }
171
172 /**
173 * @tc.name: PutGetDelete001
174 * @tc.desc: put value and delete value
175 * @tc.type: FUNC
176 * @tc.require: I5DE2A
177 * @tc.author: Sven Wang
178 */
179 HWTEST_F(DeviceKvStoreTest, PutGetDelete001, TestSize.Level1)
180 {
181 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
182
183 Key skey = {"single_001"};
184 Value sval = {"value_001"};
185 auto status = kvStore_->Put(skey, sval);
186 EXPECT_EQ(status, Status::SUCCESS) << "Put data failed";
187
188 auto delStatus = kvStore_->Delete(skey);
189 EXPECT_EQ(delStatus, Status::SUCCESS) << "Delete data failed";
190
191 auto notExistStatus = kvStore_->Delete(skey);
192 EXPECT_EQ(notExistStatus, Status::SUCCESS) << "Delete non-existing data failed";
193
194 auto spaceStatus = kvStore_->Put(skey, {""});
195 EXPECT_EQ(spaceStatus, Status::SUCCESS) << "Put space failed";
196
197 auto spaceKeyStatus = kvStore_->Put({""}, {""});
198 EXPECT_NE(spaceKeyStatus, Status::SUCCESS) << "Put space keys failed";
199
200 Status validStatus = kvStore_->Put(skey, sval);
201 EXPECT_EQ(validStatus, Status::SUCCESS) << "Put valid keys and values failed";
202
203 Value rVal;
204 auto validPutStatus = kvStore_->Get({ GetKey("single_001")}, rVal);
205 EXPECT_EQ(validPutStatus, Status::SUCCESS) << "Get value failed";
206 EXPECT_EQ(sval, rVal) << "Got and put values not equal";
207 }
208
209 /**
210 * @tc.name: GetDataQueryEntriesAndResultSet
211 * @tc.desc: get entries and result set by data query.
212 * @tc.type: FUNC
213 * @tc.require: I5DE2A
214 * @tc.author: Sven Wang
215 */
216 HWTEST_F(DeviceKvStoreTest, GetDataQueryEntriesAndResultSet, TestSize.Level1)
217 {
218 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
219
220 // prepare 10
221 size_t sum = 10;
222 int sumGet = 0;
223 std::string prefix = "prefix_";
224 for (size_t i = 0; i < sum; i++) {
225 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
226 }
227
228 DataQuery dataQuery;
229 dataQuery.KeyPrefix(prefix);
230 dataQuery.DeviceId(deviceId_);
231 kvStore_->GetCount(dataQuery, sumGet);
232 EXPECT_EQ(sumGet, sum) << "count is not equal 10.";
233
234 std::vector<Entry> results;
235 kvStore_->GetEntries(dataQuery, results);
236 EXPECT_EQ(results.size(), sum) << "entries size is not equal 10.";
237
238 std::shared_ptr<KvStoreResultSet> resultSet;
239 Status status = kvStore_->GetResultSet(dataQuery, resultSet);
240 EXPECT_EQ(status, Status::SUCCESS);
241 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 10.";
242 resultSet->IsFirst();
243 resultSet->IsAfterLast();
244 resultSet->IsBeforeFirst();
245 resultSet->MoveToPosition(1);
246 resultSet->IsLast();
247 resultSet->MoveToPrevious();
248 resultSet->MoveToNext();
249 resultSet->MoveToLast();
250 resultSet->MoveToFirst();
251 resultSet->GetPosition();
252 Entry entry;
253 resultSet->GetEntry(entry);
254
255 for (size_t i = 0; i < sum; i++) {
256 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
257 }
258
259 status = kvStore_->CloseResultSet(resultSet);
260 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
261 }
262
263 /**
264 * @tc.name: GetPrefixQueryEntriesAndResultSet
265 * @tc.desc: get entries and result set by prefix query.
266 * @tc.type: FUNC
267 * @tc.require: I5DE2A
268 * @tc.author: Sven Wang
269 */
270 HWTEST_F(DeviceKvStoreTest, GetPrefixQueryEntriesAndResultSet, TestSize.Level1)
271 {
272 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
273 if (options_.baseDir.empty()) {
274 return;
275 }
276
277 // prepare 10
278 size_t sum = 10;
279 std::string prefix = "prefix_";
280 for (size_t i = 0; i < sum; i++) {
281 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
282 }
283
284 DataQuery dataQuery;
285 dataQuery.KeyPrefix(GetKey(prefix));
286 int sumGet = 0;
287 kvStore_->GetCount(dataQuery, sumGet);
288 EXPECT_EQ(sumGet, sum) << "count is not equal 10.";
289 dataQuery.Limit(10, 0);
290 std::vector<Entry> results;
291 kvStore_->GetEntries(dataQuery, results);
292 EXPECT_EQ(results.size(), sum) << "entries size is not equal 10.";
293
294 std::shared_ptr<KvStoreResultSet> resultSet;
295 Status status = kvStore_->GetResultSet(dataQuery, resultSet);
296 EXPECT_EQ(status, Status::SUCCESS);
297 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 10.";
298 resultSet->IsFirst();
299 resultSet->IsAfterLast();
300 resultSet->IsBeforeFirst();
301 resultSet->MoveToPosition(1);
302 resultSet->IsLast();
303 resultSet->MoveToPrevious();
304 resultSet->MoveToNext();
305 resultSet->MoveToLast();
306 resultSet->MoveToFirst();
307 resultSet->GetPosition();
308 Entry entry;
309 resultSet->GetEntry(entry);
310
311 for (size_t i = 0; i < sum; i++) {
312 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
313 }
314
315 status = kvStore_->CloseResultSet(resultSet);
316 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
317 }
318
319 /**
320 * @tc.name: GetInKeysQueryResultSet
321 * @tc.desc: get entries and result set by prefix query.
322 * @tc.type: FUNC
323 * @tc.require: I5DE2A
324 * @tc.author: Sven Wang
325 */
326 HWTEST_F(DeviceKvStoreTest, GetInKeysQueryResultSet, TestSize.Level1)
327 {
328 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
329 if (options_.baseDir.empty()) {
330 return;
331 }
332
333 // prepare 10
334 size_t sum = 10;
335
336 std::string prefix = "prefix_";
337 for (size_t i = 0; i < sum; i++) {
338 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
339 }
340
341 DataQuery dataQuery;
342 dataQuery.InKeys({"prefix_0", "prefix_1", "prefix_3", "prefix_9"});
343 int sumGet = 0;
344 kvStore_->GetCount(dataQuery, sumGet);
345 EXPECT_EQ(sumGet, 4) << "count is not equal 4.";
346 dataQuery.Limit(10, 0);
347 std::shared_ptr<KvStoreResultSet> resultSet;
348 Status status = kvStore_->GetResultSet(dataQuery, resultSet);
349 EXPECT_EQ(status, Status::SUCCESS);
350 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 4.";
351 resultSet->IsFirst();
352 resultSet->IsAfterLast();
353 resultSet->IsBeforeFirst();
354 resultSet->MoveToPosition(1);
355 resultSet->IsLast();
356 resultSet->MoveToPrevious();
357 resultSet->MoveToNext();
358 resultSet->MoveToLast();
359 resultSet->MoveToFirst();
360 resultSet->GetPosition();
361 Entry entry;
362 resultSet->GetEntry(entry);
363
364 for (size_t i = 0; i < sum; i++) {
365 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
366 }
367
368 status = kvStore_->CloseResultSet(resultSet);
369 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
370 }
371
372 /**
373 * @tc.name: GetPrefixEntriesAndResultSet
374 * @tc.desc: get entries and result set by prefix.
375 * @tc.type: FUNC
376 * @tc.require: I5DE2A
377 * @tc.author: Sven Wang
378 */
379 HWTEST_F(DeviceKvStoreTest, GetPrefixEntriesAndResultSet, TestSize.Level1)
380 {
381 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
382
383 // prepare 10
384 size_t sum = 10;
385 int sumGet = 10;
386 std::string prefix = "prefix_";
387 for (size_t i = 0; i < sum; i++) {
388 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
389 }
390 std::vector<Entry> results;
391 kvStore_->GetEntries(GetKey(prefix + " "), results);
392 EXPECT_EQ(results.size(), sum) << "entries size is not equal 10.";
393
394 std::shared_ptr<KvStoreResultSet> resultSet;
395 Status status = kvStore_->GetResultSet({ GetKey(std::string(" ") + prefix + " ") }, resultSet);
396 EXPECT_EQ(status, Status::SUCCESS);
397 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 10.";
398 resultSet->IsFirst();
399 resultSet->IsAfterLast();
400 resultSet->IsBeforeFirst();
401 resultSet->MoveToPosition(1);
402 resultSet->IsLast();
403 resultSet->MoveToPrevious();
404 resultSet->MoveToNext();
405 resultSet->MoveToLast();
406 resultSet->MoveToFirst();
407 resultSet->GetPosition();
408 Entry entry;
409 resultSet->GetEntry(entry);
410
411 for (size_t i = 0; i < sum; i++) {
412 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
413 }
414
415 status = kvStore_->CloseResultSet(resultSet);
416 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
417 }
418
419 /**
420 * @tc.name: Subscribe001
421 * @tc.desc: Put data and get callback.
422 * @tc.type: FUNC
423 * @tc.require: I5DE2A
424 * @tc.author: Sven Wang
425 */
426 HWTEST_F(DeviceKvStoreTest, Subscribe001, TestSize.Level1)
427 {
428 auto observer = std::make_shared<DeviceObserverTestImpl>();
429 auto subStatus = kvStore_->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer);
430 EXPECT_EQ(subStatus, Status::SUCCESS) << "Subscribe observer failed.";
431 // subscribe repeated observer;
432 auto repeatedSubStatus = kvStore_->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer);
433 EXPECT_NE(repeatedSubStatus, Status::SUCCESS) << "Repeat subscribe kvStore observer failed.";
434
435 auto unSubStatus = kvStore_->UnSubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer);
436 EXPECT_EQ(unSubStatus, Status::SUCCESS) << "Unsubscribe observer failed.";
437 }
438
439 /**
440 * @tc.name: SyncCallback001
441 * @tc.desc: Register sync callback.
442 * @tc.type: FUNC
443 * @tc.require: I5DE2A
444 * @tc.author: Sven Wang
445 */
446 HWTEST_F(DeviceKvStoreTest, SyncCallback001, TestSize.Level1)
447 {
448 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
449
450 auto syncCallback = std::make_shared<DeviceSyncCallbackTestImpl>();
451 auto syncStatus = kvStore_->RegisterSyncCallback(syncCallback);
452 EXPECT_EQ(syncStatus, Status::SUCCESS) << "Register sync callback failed.";
453
454 auto unRegStatus = kvStore_->UnRegisterSyncCallback();
455 EXPECT_EQ(unRegStatus, Status::SUCCESS) << "Unregister sync callback failed.";
456
457 Key skey = {"single_001"};
458 Value sval = {"value_001"};
459 kvStore_->Put(skey, sval);
460 kvStore_->Delete(skey);
461
462 std::map<std::string, Status> results;
463 results.insert({"aaa", Status::INVALID_ARGUMENT});
464 syncCallback->SyncCompleted(results);
465 }
466
467 /**
468 * @tc.name: RemoveDeviceData001
469 * @tc.desc: Remove device data.
470 * @tc.type: FUNC
471 * @tc.require: I5DE2A
472 * @tc.author: Sven Wang
473 */
474 HWTEST_F(DeviceKvStoreTest, RemoveDeviceData001, TestSize.Level1)
475 {
476 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
477
478 Key skey = {"single_001"};
479 Value sval = {"value_001"};
480 kvStore_->Put(skey, sval);
481
482 std::string deviceId = "no_exist_device_id";
483 auto removeStatus = kvStore_->RemoveDeviceData(deviceId);
484 EXPECT_NE(removeStatus, Status::SUCCESS) << "Remove device should not return success";
485
486 Value retVal;
487 auto getRet = kvStore_->Get(GetKey(skey.ToString()), retVal);
488 EXPECT_EQ(getRet, Status::SUCCESS) << "Get value failed.";
489 EXPECT_EQ(retVal.Size(), sval.Size()) << "data base should be null.";
490 }
491
492 /**
493 * @tc.name: SyncData001
494 * @tc.desc: Synchronize device data.
495 * @tc.type: FUNC
496 * @tc.require: I5DE2A
497 * @tc.author: Sven Wang
498 */
499 HWTEST_F(DeviceKvStoreTest, SyncData001, TestSize.Level1)
500 {
501 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
502 std::string deviceId = "no_exist_device_id";
503 std::vector<std::string> deviceIds = { deviceId };
504 auto syncStatus = kvStore_->Sync(deviceIds, SyncMode::PUSH);
505 EXPECT_NE(syncStatus, Status::SUCCESS) << "Sync device should not return success";
506 }
507
508 /**
509 * @tc.name: TestSchemaStoreC001
510 * @tc.desc: Test schema device store.
511 * @tc.type: FUNC
512 * @tc.require: I5DE2A
513 * @tc.author: Sven Wang
514 */
515 HWTEST_F(DeviceKvStoreTest, TestSchemaStoreC001, TestSize.Level1)
516 {
517 std::shared_ptr<SingleKvStore> deviceKvStore;
518 DistributedKvDataManager manager;
519 Options options;
520 options.encrypt = true;
521 options.schema = VALID_SCHEMA;
522 options.area = EL1;
523 options.baseDir = std::string("/data/service/el1/public/database/odmf");
524 AppId appId = { "odmf" };
525 StoreId storeId = { "schema_device_id" };
526 (void)manager.GetSingleKvStore(options, appId, storeId, deviceKvStore);
527 ASSERT_NE(deviceKvStore, nullptr) << "kvStorePtr is null.";
528 auto result = deviceKvStore->GetStoreId();
529 EXPECT_EQ(result.storeId, "schema_device_id");
530
531 Key testKey = {"TestSchemaStoreC001_key"};
532 Value testValue = {"{\"age\":10}"};
533 auto testStatus = deviceKvStore->Put(testKey, testValue);
534 EXPECT_EQ(testStatus, Status::SUCCESS) << "putting data failed";
535 Value resultValue;
536 auto status = deviceKvStore->Get(GetKey(testKey.ToString()), resultValue);
537 EXPECT_EQ(status, Status::SUCCESS) << "get value failed.";
538 manager.DeleteKvStore(appId, storeId, options.baseDir);
539 }
540
541 /**
542 * @tc.name: SyncData001
543 * @tc.desc: Synchronize device data.
544 * @tc.type: FUNC
545 * @tc.require: I5DE2A
546 * @tc.author: Sven Wang
547 */
548 HWTEST_F(DeviceKvStoreTest, SyncData002, TestSize.Level1)
549 {
550 EXPECT_NE(kvStore_, nullptr) << "kvStorePtr is null.";
551 std::string deviceId = "no_exist_device_id";
552 std::vector<std::string> deviceIds = { deviceId };
553 uint32_t allowedDelayMs = 200;
554 auto syncStatus = kvStore_->Sync(deviceIds, SyncMode::PUSH, allowedDelayMs);
555 EXPECT_EQ(syncStatus, Status::SUCCESS) << "sync device should return success";
556 }
557
558 /**
559 * @tc.name: SyncData002
560 * @tc.desc: Set sync parameters - success.
561 * @tc.type: FUNC
562 * @tc.require: I5DE2A
563 * @tc.author: Sven Wang
564 */
565 HWTEST_F(DeviceKvStoreTest, SetSync001, TestSize.Level1)
566 {
567 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
568 KvSyncParam syncParam{ 500 }; // 500ms
569 auto ret = kvStore_->SetSyncParam(syncParam);
570 EXPECT_EQ(ret, Status::SUCCESS) << "set sync param should return success";
571
572 KvSyncParam syncParamRet;
573 kvStore_->GetSyncParam(syncParamRet);
574 EXPECT_EQ(syncParamRet.allowedDelayMs, syncParam.allowedDelayMs);
575 }
576
577 /**
578 * @tc.name: SyncData002
579 * @tc.desc: Set sync parameters - failed.
580 * @tc.type: FUNC
581 * @tc.require: I5DE2A
582 * @tc.author: Sven Wang
583 */
584 HWTEST_F(DeviceKvStoreTest, SetSync002, TestSize.Level1)
585 {
586 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
587 KvSyncParam syncParam2{ 50 }; // 50ms
588 auto ret = kvStore_->SetSyncParam(syncParam2);
589 EXPECT_NE(ret, Status::SUCCESS) << "set sync param should not return success";
590
591 KvSyncParam syncParamRet2;
592 ret = kvStore_->GetSyncParam(syncParamRet2);
593 EXPECT_NE(syncParamRet2.allowedDelayMs, syncParam2.allowedDelayMs);
594 }
595
596 /**
597 * @tc.name: SingleKvStoreDdmPutBatch001
598 * @tc.desc: Batch put data.
599 * @tc.type: FUNC
600 * @tc.require: I5DE2A
601 * @tc.author: Sven Wang
602 */
603 HWTEST_F(DeviceKvStoreTest, SingleKvStoreDdmPutBatch001, TestSize.Level2)
604 {
605 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
606
607 // store entries to kvstore.
608 std::vector<Entry> entries;
609 Entry entry1, entry2, entry3;
610 entry1.key = "KvStoreDdmPutBatch001_1";
611 entry1.value = "age:20";
612 entry2.key = "KvStoreDdmPutBatch001_2";
613 entry2.value = "age:19";
614 entry3.key = "KvStoreDdmPutBatch001_3";
615 entry3.value = "age:23";
616 entries.push_back(entry1);
617 entries.push_back(entry2);
618 entries.push_back(entry3);
619
620 Status status = kvStore_->PutBatch(entries);
621 EXPECT_EQ(Status::SUCCESS, status) << "PutBatch data return wrong status";
622 // get value from kvstore.
623 Value valueRet1;
624 Status statusRet1 = kvStore_->Get(GetKey(entry1.key.ToString()), valueRet1);
625 EXPECT_EQ(Status::SUCCESS, statusRet1) << "Get data return wrong status";
626 EXPECT_EQ(entry1.value, valueRet1) << "value and valueRet are not equal";
627
628 Value valueRet2;
629 Status statusRet2 = kvStore_->Get(GetKey(entry2.key.ToString()), valueRet2);
630 EXPECT_EQ(Status::SUCCESS, statusRet2) << "Get data return wrong status";
631 EXPECT_EQ(entry2.value, valueRet2) << "value and valueRet are not equal";
632
633 Value valueRet3;
634 Status statusRet3 = kvStore_->Get(GetKey(entry3.key.ToString()), valueRet3);
635 EXPECT_EQ(Status::SUCCESS, statusRet3) << "Get data return wrong status";
636 EXPECT_EQ(entry3.value, valueRet3) << "value and valueRet are not equal";
637 }
638
639 /**
640 * @tc.name: SingleKvStoreDdmPutBatch002
641 * @tc.desc: Batch update data.
642 * @tc.type: FUNC
643 * @tc.require: I5DE2A
644 * @tc.author: Sven Wang
645 */
646 HWTEST_F(DeviceKvStoreTest, SingleKvStoreDdmPutBatch002, TestSize.Level2)
647 {
648 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
649
650 // before update.
651 std::vector<Entry> entriesBefore;
652 Entry entry1, entry2, entry3;
653 entry1.key = "SingleKvStoreDdmPutBatch002_1";
654 entry1.value = "age:20";
655 entry2.key = "SingleKvStoreDdmPutBatch002_2";
656 entry2.value = "age:19";
657 entry3.key = "SingleKvStoreDdmPutBatch002_3";
658 entry3.value = "age:23";
659 entriesBefore.push_back(entry1);
660 entriesBefore.push_back(entry2);
661 entriesBefore.push_back(entry3);
662
663 Status status = kvStore_->PutBatch(entriesBefore);
664 EXPECT_EQ(Status::SUCCESS, status) << "PutBatch data return wrong status";
665
666 // after update.
667 std::vector<Entry> entriesAfter;
668 Entry entry4, entry5, entry6;
669 entry4.key = "SingleKvStoreDdmPutBatch002_1";
670 entry4.value = "age:20, sex:girl";
671 entry5.key = "SingleKvStoreDdmPutBatch002_2";
672 entry5.value = "age:19, sex:boy";
673 entry6.key = "SingleKvStoreDdmPutBatch002_3";
674 entry6.value = "age:23, sex:girl";
675 entriesAfter.push_back(entry4);
676 entriesAfter.push_back(entry5);
677 entriesAfter.push_back(entry6);
678
679 status = kvStore_->PutBatch(entriesAfter);
680 EXPECT_EQ(Status::SUCCESS, status) << "PutBatch failed, wrong status";
681
682 // get value from kvstore.
683 Value valueRet1;
684 Status statusRet1 = kvStore_->Get(GetKey(entry4.key.ToString()), valueRet1);
685 EXPECT_EQ(Status::SUCCESS, statusRet1) << "Get data failed, wrong status";
686 EXPECT_EQ(entry4.value, valueRet1) << "value and valueRet are not equal";
687
688 Value valueRet2;
689 Status statusRet2 = kvStore_->Get(GetKey(entry5.key.ToString()), valueRet2);
690 EXPECT_EQ(Status::SUCCESS, statusRet2) << "Get data failed, wrong status";
691 EXPECT_EQ(entry5.value, valueRet2) << "value and valueRet are not equal";
692
693 Value valueRet3;
694 Status statusRet3 = kvStore_->Get(GetKey(entry6.key.ToString()), valueRet3);
695 EXPECT_EQ(Status::SUCCESS, statusRet3) << "Get data return wrong status";
696 EXPECT_EQ(entry6.value, valueRet3) << "value and valueRet are not equal";
697 }
698
699 /**
700 * @tc.name: DdmPutBatch003
701 * @tc.desc: Batch put data that contains invalid data.
702 * @tc.type: FUNC
703 * @tc.require: I5DE2A
704 * @tc.author: Sven Wang
705 */
706 HWTEST_F(DeviceKvStoreTest, DdmPutBatch003, TestSize.Level2)
707 {
708 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
709
710 std::vector<Entry> entries;
711 Entry entry1, entry2, entry3;
712 entry1.key = " ";
713 entry1.value = "age:20";
714 entry2.key = "student_name_caixu";
715 entry2.value = " ";
716 entry3.key = "student_name_liuyue";
717 entry3.value = "age:23";
718 entries.push_back(entry1);
719 entries.push_back(entry2);
720 entries.push_back(entry3);
721
722 Status status = kvStore_->PutBatch(entries);
723 Status target = options_.baseDir.empty() ? Status::SUCCESS : Status::INVALID_ARGUMENT;
724 EXPECT_EQ(target, status) << "PutBatch data return wrong status";
725 }
726
727 /**
728 * @tc.name: DdmPutBatch004
729 * @tc.desc: Batch put data that contains invalid data.
730 * @tc.type: FUNC
731 * @tc.require: I5DE2A
732 * @tc.author: Sven Wang
733 */
734 HWTEST_F(DeviceKvStoreTest, DdmPutBatch004, TestSize.Level2)
735 {
736 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
737
738 std::vector<Entry> entries;
739 Entry entry1, entry2, entry3;
740 entry1.key = "";
741 entry1.value = "age:20";
742 entry2.key = "student_name_caixu";
743 entry2.value = "";
744 entry3.key = "student_name_liuyue";
745 entry3.value = "age:23";
746 entries.push_back(entry1);
747 entries.push_back(entry2);
748 entries.push_back(entry3);
749
750 Status status = kvStore_->PutBatch(entries);
751 Status target = options_.baseDir.empty() ? Status::SUCCESS : Status::INVALID_ARGUMENT;
752 EXPECT_EQ(target, status) << "PutBatch data return wrong status";
753 }
754
SingleGenerate1025KeyLen()755 static std::string SingleGenerate1025KeyLen()
756 {
757 std::string str("prefix");
758 // Generate a key with a length of more than 1024 bytes.
759 for (int i = 0; i < 1024; i++) {
760 str += "a";
761 }
762 return str;
763 }
764 /**
765 * @tc.name: DdmPutBatch005
766 * @tc.desc: Batch put data that contains invalid data.
767 * @tc.type: FUNC
768 * @tc.require: I5DE2A
769 * @tc.author: Sven Wang
770 */
771 HWTEST_F(DeviceKvStoreTest, DdmPutBatch005, TestSize.Level2)
772 {
773 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
774 std::vector<Entry> entries;
775 Entry entry1, entry2, entry3;
776 entry1.key = SingleGenerate1025KeyLen();
777 entry1.value = "age:20";
778 entry2.key = "student_name_caixu";
779 entry2.value = "age:19";
780 entry3.key = "student_name_liuyue";
781 entry3.value = "age:23";
782 entries.push_back(entry1);
783 entries.push_back(entry2);
784 entries.push_back(entry3);
785
786 Status status = kvStore_->PutBatch(entries);
787 EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "PutBatch data return wrong status";
788 }
789
790 /**
791 * @tc.name: DdmPutBatch006
792 * @tc.desc: Batch put large data.
793 * @tc.type: FUNC
794 * @tc.require: I5DE2A
795 * @tc.author: Sven Wang
796 */
797 HWTEST_F(DeviceKvStoreTest, DdmPutBatch006, TestSize.Level2)
798 {
799 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
800
801 std::vector<uint8_t> val(MAX_VALUE_SIZE);
802 for (int i = 0; i < MAX_VALUE_SIZE; i++) {
803 val[i] = static_cast<uint8_t>(i);
804 }
805 Value value = val;
806
807 std::vector<Entry> entries;
808 Entry entry1, entry2, entry3;
809 entry1.key = "SingleKvStoreDdmPutBatch006_1";
810 entry1.value = value;
811 entry2.key = "SingleKvStoreDdmPutBatch006_2";
812 entry2.value = value;
813 entry3.key = "SingleKvStoreDdmPutBatch006_3";
814 entry3.value = value;
815 entries.push_back(entry1);
816 entries.push_back(entry2);
817 entries.push_back(entry3);
818 Status status = kvStore_->PutBatch(entries);
819 EXPECT_EQ(Status::SUCCESS, status) << "PutBatch data return wrong status";
820
821 // get value from kvstore.
822 Value valueRet1;
823 Status statusRet1 = kvStore_->Get(GetKey("SingleKvStoreDdmPutBatch006_1"), valueRet1);
824 EXPECT_EQ(Status::SUCCESS, statusRet1) << "Get data return wrong status";
825 EXPECT_EQ(entry1.value, valueRet1) << "value and valueRet are not equal";
826
827 Value valueRet2;
828 Status statusRet2 = kvStore_->Get(GetKey("SingleKvStoreDdmPutBatch006_2"), valueRet2);
829 EXPECT_EQ(Status::SUCCESS, statusRet2) << "Get data return wrong status";
830 EXPECT_EQ(entry2.value, valueRet2) << "value and valueRet are not equal";
831
832 Value valueRet3;
833 Status statusRet3 = kvStore_->Get(GetKey("SingleKvStoreDdmPutBatch006_3"), valueRet3);
834 EXPECT_EQ(Status::SUCCESS, statusRet3) << "Get data return wrong status";
835 EXPECT_EQ(entry3.value, valueRet3) << "value and valueRet are not equal";
836 }
837
838 /**
839 * @tc.name: DdmDeleteBatch001
840 * @tc.desc: Batch delete data.
841 * @tc.type: FUNC
842 * @tc.require: I5DE2A
843 * @tc.author: Sven Wang
844 */
845 HWTEST_F(DeviceKvStoreTest, DdmDeleteBatch001, TestSize.Level2)
846 {
847 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
848
849 // store entries to kvstore.
850 std::vector<Entry> entries;
851 Entry entry1, entry2, entry3;
852 entry1.key = "SingleKvStoreDdmDeleteBatch001_1";
853 entry1.value = "age:20";
854 entry2.key = "SingleKvStoreDdmDeleteBatch001_2";
855 entry2.value = "age:19";
856 entry3.key = "SingleKvStoreDdmDeleteBatch001_3";
857 entry3.value = "age:23";
858 entries.push_back(entry1);
859 entries.push_back(entry2);
860 entries.push_back(entry3);
861
862 std::vector<Key> keys;
863 keys.push_back("SingleKvStoreDdmDeleteBatch001_1");
864 keys.push_back("SingleKvStoreDdmDeleteBatch001_2");
865 keys.push_back("SingleKvStoreDdmDeleteBatch001_3");
866
867 Status status1 = kvStore_->PutBatch(entries);
868 EXPECT_EQ(Status::SUCCESS, status1) << "PutBatch data return wrong status";
869
870 Status status2 = kvStore_->DeleteBatch(keys);
871 EXPECT_EQ(Status::SUCCESS, status2) << "DeleteBatch data return wrong status";
872 std::vector<Entry> results;
873 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch001_"), results);
874 size_t sum = 0;
875 EXPECT_EQ(results.size(), sum) << "entries size is not equal 0.";
876 }
877
878 /**
879 * @tc.name: DdmDeleteBatch002
880 * @tc.desc: Batch delete data when some keys are not in KvStore.
881 * @tc.type: FUNC
882 * @tc.require: I5DE2A
883 * @tc.author: Sven Wang
884 */
885 HWTEST_F(DeviceKvStoreTest, DdmDeleteBatch002, TestSize.Level2)
886 {
887 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
888
889 // store entries to kvstore.
890 std::vector<Entry> entries;
891 Entry entry1, entry2, entry3;
892 entry1.key = "SingleKvStoreDdmDeleteBatch002_1";
893 entry1.value = "age:20";
894 entry2.key = "SingleKvStoreDdmDeleteBatch002_2";
895 entry2.value = "age:19";
896 entry3.key = "SingleKvStoreDdmDeleteBatch002_3";
897 entry3.value = "age:23";
898 entries.push_back(entry1);
899 entries.push_back(entry2);
900 entries.push_back(entry3);
901
902 std::vector<Key> keys;
903 keys.push_back("SingleKvStoreDdmDeleteBatch002_1");
904 keys.push_back("SingleKvStoreDdmDeleteBatch002_2");
905 keys.push_back("SingleKvStoreDdmDeleteBatch002_3");
906 keys.push_back("SingleKvStoreDdmDeleteBatch002_4");
907
908 Status status1 = kvStore_->PutBatch(entries);
909 EXPECT_EQ(Status::SUCCESS, status1) << "PutBatch data return wrong status";
910
911 Status status2 = kvStore_->DeleteBatch(keys);
912 EXPECT_EQ(Status::SUCCESS, status2) << "DeleteBatch data return wrong status";
913 std::vector<Entry> results;
914 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch002_"), results);
915 size_t sum = 0;
916 EXPECT_EQ(results.size(), sum) << "entries size is not equal 0.";
917 }
918
919 /**
920 * @tc.name: DdmDeleteBatch003
921 * @tc.desc: Batch delete data when some keys are invalid.
922 * @tc.type: FUNC
923 * @tc.require: I5DE2A
924 * @tc.author: Sven Wang
925 */
926 HWTEST_F(DeviceKvStoreTest, DdmDeleteBatch003, TestSize.Level2)
927 {
928 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
929
930 // Store entries to KvStore.
931 std::vector<Entry> entries;
932 Entry entry1, entry2, entry3;
933 entry1.key = "SingleKvStoreDdmDeleteBatch003_1";
934 entry1.value = "age:20";
935 entry2.key = "SingleKvStoreDdmDeleteBatch003_2";
936 entry2.value = "age:19";
937 entry3.key = "SingleKvStoreDdmDeleteBatch003_3";
938 entry3.value = "age:23";
939 entries.push_back(entry1);
940 entries.push_back(entry2);
941 entries.push_back(entry3);
942
943 std::vector<Key> keys;
944 keys.push_back("SingleKvStoreDdmDeleteBatch003_1");
945 keys.push_back("SingleKvStoreDdmDeleteBatch003_2");
946 keys.push_back("");
947
948 Status status1 = kvStore_->PutBatch(entries);
949 EXPECT_EQ(Status::SUCCESS, status1) << "PutBatch data return wrong status";
950
951 Status status2 = kvStore_->DeleteBatch(keys);
952 Status target = options_.baseDir.empty() ? Status::SUCCESS : Status::INVALID_ARGUMENT;
953 size_t sum = options_.baseDir.empty() ? 1 : 3;
954 EXPECT_EQ(target, status2) << "DeleteBatch data return wrong status";
955 std::vector<Entry> results;
956 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch003_"), results);
957 EXPECT_EQ(results.size(), sum) << "entries size is not equal 3.";
958 }
959
960 /**
961 * @tc.name: DdmDeleteBatch004
962 * @tc.desc: Batch delete data when some keys are invalid.
963 * @tc.type: FUNC
964 * @tc.require: I5DE2A
965 * @tc.author: Sven Wang
966 */
967 HWTEST_F(DeviceKvStoreTest, DdmDeleteBatch004, TestSize.Level2)
968 {
969 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
970
971 // store entries to kvstore.
972 std::vector<Entry> entries;
973 Entry entry1, entry2, entry3;
974 entry1.key = "SingleKvStoreDdmDeleteBatch004_1";
975 entry1.value = "age:20";
976 entry2.key = "SingleKvStoreDdmDeleteBatch004_2";
977 entry2.value = "age:19";
978 entry3.key = "SingleKvStoreDdmDeleteBatch004_3";
979 entry3.value = "age:23";
980 entries.push_back(entry1);
981 entries.push_back(entry2);
982 entries.push_back(entry3);
983
984 std::vector<Key> keys;
985 keys.push_back("SingleKvStoreDdmDeleteBatch004_1");
986 keys.push_back("SingleKvStoreDdmDeleteBatch004_2");
987 keys.push_back(" ");
988
989 Status status1 = kvStore_->PutBatch(entries);
990 EXPECT_EQ(Status::SUCCESS, status1) << "PutBatch data return wrong status";
991
992 std::vector<Entry> results1;
993 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch004_"), results1);
994 size_t sum1 = 3;
995 EXPECT_EQ(results1.size(), sum1) << "entries size1111 is not equal 3.";
996
997 Status status2 = kvStore_->DeleteBatch(keys);
998 Status target = options_.baseDir.empty() ? Status::SUCCESS : Status::INVALID_ARGUMENT;
999 size_t sum = options_.baseDir.empty() ? 1 : 3;
1000 EXPECT_EQ(target, status2) << "DeleteBatch data return wrong status";
1001 std::vector<Entry> results;
1002 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch004_"), results);
1003 EXPECT_EQ(results.size(), sum) << "entries size is not equal 3.";
1004 }
1005
1006 /**
1007 * @tc.name: DdmDeleteBatch005
1008 * @tc.desc: Batch delete data when some keys are invalid.
1009 * @tc.type: FUNC
1010 * @tc.require: I5DE2A
1011 * @tc.author: Sven Wang
1012 */
1013 HWTEST_F(DeviceKvStoreTest, DdmDeleteBatch005, TestSize.Level2)
1014 {
1015 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
1016
1017 // store entries to kvstore.
1018 std::vector<Entry> entries;
1019 Entry entry1, entry2, entry3;
1020 entry1.key = "SingleKvStoreDdmDeleteBatch005_1";
1021 entry1.value = "age:20";
1022 entry2.key = "SingleKvStoreDdmDeleteBatch005_2";
1023 entry2.value = "age:19";
1024 entry3.key = "SingleKvStoreDdmDeleteBatch005_3";
1025 entry3.value = "age:23";
1026 entries.push_back(entry1);
1027 entries.push_back(entry2);
1028 entries.push_back(entry3);
1029
1030 std::vector<Key> keys;
1031 keys.push_back("SingleKvStoreDdmDeleteBatch005_1");
1032 keys.push_back("SingleKvStoreDdmDeleteBatch005_2");
1033 Key keyTmp = SingleGenerate1025KeyLen();
1034 keys.push_back(keyTmp);
1035
1036 Status status1 = kvStore_->PutBatch(entries);
1037 EXPECT_EQ(Status::SUCCESS, status1) << "PutBatch data return wrong status";
1038
1039 std::vector<Entry> results1;
1040 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch005_"), results1);
1041 size_t sum1 = 3;
1042 EXPECT_EQ(results1.size(), sum1) << "entries111 size is not equal 3.";
1043
1044 Status status2 = kvStore_->DeleteBatch(keys);
1045 EXPECT_EQ(Status::INVALID_ARGUMENT, status2) << "DeleteBatch data return wrong status";
1046 std::vector<Entry> results;
1047 kvStore_->GetEntries(GetKey("SingleKvStoreDdmDeleteBatch005_"), results);
1048 size_t sum = 3;
1049 EXPECT_EQ(results.size(), sum) << "entries size is not equal 3.";
1050 }
1051
1052 /**
1053 * @tc.name: Transaction001
1054 * @tc.desc: Batch delete data when some keys are invalid.
1055 * @tc.type: FUNC
1056 * @tc.require: I5DE2A
1057 * @tc.author: Sven Wang
1058 */
1059 HWTEST_F(DeviceKvStoreTest, Transaction001, TestSize.Level2)
1060 {
1061 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
1062 std::shared_ptr<DeviceObserverTestImpl> observer = std::make_shared<DeviceObserverTestImpl>();
1063 observer->ResetToZero();
1064
1065 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1066 Status status = kvStore_->SubscribeKvStore(subscribeType, observer);
1067 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1068
1069 Key key1 = "SingleKvStoreTransaction001_1";
1070 Value value1 = "subscribe";
1071
1072 std::vector<Entry> entries;
1073 Entry entry1, entry2, entry3;
1074 entry1.key = "SingleKvStoreTransaction001_2";
1075 entry1.value = "subscribe";
1076 entry2.key = "SingleKvStoreTransaction001_3";
1077 entry2.value = "subscribe";
1078 entry3.key = "SingleKvStoreTransaction001_4";
1079 entry3.value = "subscribe";
1080 entries.push_back(entry1);
1081 entries.push_back(entry2);
1082 entries.push_back(entry3);
1083
1084 std::vector<Key> keys;
1085 keys.push_back("SingleKvStoreTransaction001_2");
1086 keys.push_back("ISingleKvStoreTransaction001_3");
1087
1088 status = kvStore_->StartTransaction();
1089 EXPECT_EQ(Status::SUCCESS, status) << "StartTransaction return wrong status";
1090
1091 status = kvStore_->Put(key1, value1); // insert or update key-value
1092 EXPECT_EQ(Status::SUCCESS, status) << "Put data return wrong status";
1093 status = kvStore_->PutBatch(entries);
1094 EXPECT_EQ(Status::SUCCESS, status) << "PutBatch data return wrong status";
1095 status = kvStore_->Delete(key1);
1096 EXPECT_EQ(Status::SUCCESS, status) << "Delete data return wrong status";
1097 status = kvStore_->DeleteBatch(keys);
1098 EXPECT_EQ(Status::SUCCESS, status) << "DeleteBatch data return wrong status";
1099 status = kvStore_->Commit();
1100 EXPECT_EQ(Status::SUCCESS, status) << "Commit return wrong status";
1101
1102 usleep(200000);
1103 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1104
1105 status = kvStore_->UnSubscribeKvStore(subscribeType, observer);
1106 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1107 }
1108
1109 /**
1110 * @tc.name: Transaction002
1111 * @tc.desc: Batch delete data when some keys are invalid.
1112 * @tc.type: FUNC
1113 * @tc.require: I5DE2A
1114 * @tc.author: Sven Wang
1115 */
1116 HWTEST_F(DeviceKvStoreTest, Transaction002, TestSize.Level2)
1117 {
1118 EXPECT_NE(nullptr, kvStore_) << "kvStore is nullptr";
1119 std::shared_ptr<DeviceObserverTestImpl> observer = std::make_shared<DeviceObserverTestImpl>();
1120 observer->ResetToZero();
1121
1122 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1123 Status status = kvStore_->SubscribeKvStore(subscribeType, observer);
1124 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1125
1126 Key key1 = "SingleKvStoreTransaction002_1";
1127 Value value1 = "subscribe";
1128
1129 std::vector<Entry> entries;
1130 Entry entry1, entry2, entry3;
1131 entry1.key = "SingleKvStoreTransaction002_2";
1132 entry1.value = "subscribe";
1133 entry2.key = "SingleKvStoreTransaction002_3";
1134 entry2.value = "subscribe";
1135 entry3.key = "SingleKvStoreTransaction002_4";
1136 entry3.value = "subscribe";
1137 entries.push_back(entry1);
1138 entries.push_back(entry2);
1139 entries.push_back(entry3);
1140
1141 std::vector<Key> keys;
1142 keys.push_back("SingleKvStoreTransaction002_2");
1143 keys.push_back("SingleKvStoreTransaction002_3");
1144
1145 status = kvStore_->StartTransaction();
1146 EXPECT_EQ(Status::SUCCESS, status) << "StartTransaction return wrong status";
1147
1148 status = kvStore_->Put(key1, value1); // insert or update key-value
1149 EXPECT_EQ(Status::SUCCESS, status) << "Put data return wrong status";
1150 status = kvStore_->PutBatch(entries);
1151 EXPECT_EQ(Status::SUCCESS, status) << "PutBatch data return wrong status";
1152 status = kvStore_->Delete(key1);
1153 EXPECT_EQ(Status::SUCCESS, status) << "Delete data return wrong status";
1154 status = kvStore_->DeleteBatch(keys);
1155 EXPECT_EQ(Status::SUCCESS, status) << "DeleteBatch data return wrong status";
1156 status = kvStore_->Rollback();
1157 EXPECT_EQ(Status::SUCCESS, status) << "Commit return wrong status";
1158
1159 usleep(200000);
1160 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
1161 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 0);
1162 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 0);
1163 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1164
1165 status = kvStore_->UnSubscribeKvStore(subscribeType, observer);
1166 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1167 observer = nullptr;
1168 }
1169
1170 /**
1171 * @tc.name: DeviceSync001
1172 * @tc.desc: Test sync enable.
1173 * @tc.type: FUNC
1174 * @tc.require: I5DE2A
1175 * @tc.author: Sven Wang
1176 */
1177 HWTEST_F(DeviceKvStoreTest, DeviceSync001, TestSize.Level1)
1178 {
1179 std::shared_ptr<SingleKvStore> kvStore;
1180 DistributedKvDataManager manager;
1181 Options options;
1182 options.encrypt = true;
1183 options.area = EL1;
1184 options.baseDir = std::string("/data/service/el1/public/database/odmf");
1185 AppId appId = { "odmf" };
1186 StoreId storeId = { "schema_device_id001" };
1187 manager.GetSingleKvStore(options, appId, storeId, kvStore);
1188 ASSERT_NE(kvStore, nullptr) << "kvStore is null.";
1189 auto result = kvStore->GetStoreId();
1190 EXPECT_EQ(result.storeId, "schema_device_id001");
1191
1192 auto testStatus = kvStore->SetCapabilityEnabled(true);
1193 EXPECT_EQ(testStatus, Status::SUCCESS) << "set fail";
1194 manager.DeleteKvStore(appId, storeId, options.baseDir);
1195 }
1196
1197 /**
1198 * @tc.name: DeviceSync002
1199 * @tc.desc: Test sync enable.
1200 * @tc.type: FUNC
1201 * @tc.require: I5DE2A
1202 * @tc.author: Sven Wang
1203 */
1204 HWTEST_F(DeviceKvStoreTest, DeviceSync002, TestSize.Level1)
1205 {
1206 std::shared_ptr<SingleKvStore> kvStore;
1207 DistributedKvDataManager manager;
1208 Options options;
1209 options.encrypt = true;
1210 options.area = EL1;
1211 options.baseDir = std::string("/data/service/el1/public/database/odmf");
1212 AppId appId = { "odmf" };
1213 StoreId storeId = { "schema_device_id002" };
1214 manager.GetSingleKvStore(options, appId, storeId, kvStore);
1215 ASSERT_NE(kvStore, nullptr) << "kvStore is null.";
1216 auto result = kvStore->GetStoreId();
1217 EXPECT_EQ(result.storeId, "schema_device_id002");
1218
1219 std::vector<std::string> local = {"A", "B"};
1220 std::vector<std::string> remote = {"C", "D"};
1221 auto testStatus = kvStore->SetCapabilityRange(local, remote);
1222 EXPECT_EQ(testStatus, Status::SUCCESS) << "set range fail";
1223 manager.DeleteKvStore(appId, storeId, options.baseDir);
1224 }
1225
1226 /**
1227 * @tc.name: SyncWithCondition001
1228 * @tc.desc: sync device data with condition;
1229 * @tc.type: FUNC
1230 * @tc.require: I5DE2A
1231 * @tc.author: Sven Wang
1232 */
1233 HWTEST_F(DeviceKvStoreTest, SyncWithCondition001, TestSize.Level1)
1234 {
1235 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
1236 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1237 DataQuery dataQuery;
1238 dataQuery.KeyPrefix("name");
1239 auto syncStatus = kvStore_->Sync(deviceIds, SyncMode::PUSH, dataQuery, nullptr);
1240 EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success";
1241 }
1242
1243 /**
1244 * @tc.name: SubscribeWithQuery001
1245 * desc: subscribe and sync device data with query;
1246 * type: FUNC
1247 * @tc.require: I5DE2A
1248 * @tc.author: Sven Wang
1249 */
1250 HWTEST_F(DeviceKvStoreTest, SubscribeWithQuery001, TestSize.Level1)
1251 {
1252 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
1253 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1254 DataQuery dataQuery;
1255 dataQuery.KeyPrefix("name");
1256 auto syncStatus = kvStore_->SubscribeWithQuery(deviceIds, dataQuery);
1257 EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success";
1258 }
1259
1260 /**
1261 * @tc.name: UnSubscribeWithQuery001
1262 * desc: subscribe and sync device data with query;
1263 * type: FUNC
1264 * @tc.require: I5DE2A
1265 * @tc.author: Sven Wang
1266 */
1267 HWTEST_F(DeviceKvStoreTest, UnSubscribeWithQuery001, TestSize.Level1)
1268 {
1269 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
1270 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1271 DataQuery dataQuery;
1272 dataQuery.KeyPrefix("name");
1273 auto unSubscribeStatus = kvStore_->UnsubscribeWithQuery(deviceIds, dataQuery);
1274 EXPECT_NE(unSubscribeStatus, Status::SUCCESS) << "sync device should not return success";
1275 }