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 namespace OHOS::Test {
29 class DeviceKvStoreTest : public testing::Test {
30 public:
31 static constexpr uint64_t MAX_VALUE_SIZE = 4 * 1024 * 1024; // max value size is 4M.
32 static void SetUpTestCase(void);
33
34 static void TearDownTestCase(void);
35
36 void SetUp();
37
38 void TearDown();
39 static std::string GetKey(const std::string &key);
40
41 static std::shared_ptr<SingleKvStore> kvStore_; // declare kvstore instance.
42 static Status status_;
43 static std::string deviceId_;
44 static Options options_;
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 DistributedKvDataManager manager;
63 options_.area = EL1;
64 options_.baseDir = std::string("/data/service/el1/public/database/odmf");
65 options_.securityLevel = S1;
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 DistributedKvDataManager manager;
78 AppId appId = { "odmf" };
79 manager.DeleteAllKvStore(appId, options_.baseDir);
80 (void)remove("/data/service/el1/public/database/odmf/key");
81 (void)remove("/data/service/el1/public/database/odmf/kvdb");
82 (void)remove("/data/service/el1/public/database/odmf");
83 }
84
SetUp(void)85 void DeviceKvStoreTest::SetUp(void)
86 {}
87
TearDown(void)88 void DeviceKvStoreTest::TearDown(void)
89 {}
90
GetKey(const std::string & key)91 std::string DeviceKvStoreTest::GetKey(const std::string& key)
92 {
93 std::ostringstream oss;
94 oss << std::setfill('0') << std::setw(sizeof(uint32_t)) << deviceId_.length();
95 oss << deviceId_ << std::string(key.begin(), key.end());
96 return oss.str();
97 }
98
99 class DeviceObserverTestImpl : public KvStoreObserver {
100 public:
101 std::vector<Entry> insertEntries_;
102 std::vector<Entry> updateEntries_;
103 std::vector<Entry> deleteEntries_;
104 bool isClear_ = false;
105 DeviceObserverTestImpl();
~DeviceObserverTestImpl()106 ~DeviceObserverTestImpl()
107 {}
108
109 DeviceObserverTestImpl(const DeviceObserverTestImpl &) = delete;
110 DeviceObserverTestImpl &operator=(const DeviceObserverTestImpl &) = delete;
111 DeviceObserverTestImpl(DeviceObserverTestImpl &&) = delete;
112 DeviceObserverTestImpl &operator=(DeviceObserverTestImpl &&) = delete;
113
114 void OnChange(const ChangeNotification &changeNotification);
115
116 // reset the callCount_ to zero.
117 void ResetToZero();
118
119 uint64_t GetCallCount() const;
120
121 private:
122 uint64_t callCount_ = 0;
123 };
124
OnChange(const ChangeNotification & changeNotification)125 void DeviceObserverTestImpl::OnChange(const ChangeNotification &changeNotification)
126 {
127 callCount_++;
128 insertEntries_ = changeNotification.GetInsertEntries();
129 updateEntries_ = changeNotification.GetUpdateEntries();
130 deleteEntries_ = changeNotification.GetDeleteEntries();
131 isClear_ = changeNotification.IsClear();
132 }
133
DeviceObserverTestImpl()134 DeviceObserverTestImpl::DeviceObserverTestImpl()
135 {
136 }
137
ResetToZero()138 void DeviceObserverTestImpl::ResetToZero()
139 {
140 callCount_ = 0;
141 }
142
GetCallCount() const143 uint64_t DeviceObserverTestImpl::GetCallCount() const
144 {
145 return callCount_;
146 }
147
148 class DeviceSyncCallbackTestImpl : public KvStoreSyncCallback {
149 public:
150 void SyncCompleted(const std::map<std::string, Status> &results);
151 };
152
SyncCompleted(const std::map<std::string,Status> & results)153 void DeviceSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Status> &results)
154 {}
155
156 /**
157 * @tc.name: GetStoreId001
158 * @tc.desc: Get a Device KvStore instance.
159 * @tc.type: FUNC
160 * @tc.require: I5DE2A
161 * @tc.author: Sven Wang
162 */
163 HWTEST_F(DeviceKvStoreTest, GetStoreId001, TestSize.Level1)
164 {
165 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
166
167 auto storID = kvStore_->GetStoreId();
168 EXPECT_EQ(storID.storeId, "student_device");
169 }
170
171 /**
172 * @tc.name: PutGetDelete001
173 * @tc.desc: put value and delete value
174 * @tc.type: FUNC
175 * @tc.require: I5DE2A
176 * @tc.author: Sven Wang
177 */
178 HWTEST_F(DeviceKvStoreTest, PutGetDelete001, TestSize.Level1)
179 {
180 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
181
182 Key skey = {"single_001"};
183 Value sval = {"value_001"};
184 auto status = kvStore_->Put(skey, sval);
185 EXPECT_EQ(status, Status::SUCCESS) << "Put data failed";
186
187 auto delStatus = kvStore_->Delete(skey);
188 EXPECT_EQ(delStatus, Status::SUCCESS) << "Delete data failed";
189
190 auto notExistStatus = kvStore_->Delete(skey);
191 EXPECT_EQ(notExistStatus, Status::SUCCESS) << "Delete non-existing data failed";
192
193 auto spaceStatus = kvStore_->Put(skey, {""});
194 EXPECT_EQ(spaceStatus, Status::SUCCESS) << "Put space failed";
195
196 auto spaceKeyStatus = kvStore_->Put({""}, {""});
197 EXPECT_NE(spaceKeyStatus, Status::SUCCESS) << "Put space keys failed";
198
199 Status validStatus = kvStore_->Put(skey, sval);
200 EXPECT_EQ(validStatus, Status::SUCCESS) << "Put valid keys and values failed";
201
202 Value rVal;
203 auto validPutStatus = kvStore_->Get({ GetKey("single_001")}, rVal);
204 EXPECT_EQ(validPutStatus, Status::SUCCESS) << "Get value failed";
205 EXPECT_EQ(sval, rVal) << "Got and put values not equal";
206 }
207
208 /**
209 * @tc.name: GetDataQueryEntriesAndResultSet
210 * @tc.desc: get entries and result set by data query.
211 * @tc.type: FUNC
212 * @tc.require: I5DE2A
213 * @tc.author: Sven Wang
214 */
215 HWTEST_F(DeviceKvStoreTest, GetDataQueryEntriesAndResultSet, TestSize.Level1)
216 {
217 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
218
219 // prepare 10
220 size_t sum = 10;
221 int sumGet = 0;
222 std::string prefix = "prefix_";
223 for (size_t i = 0; i < sum; i++) {
224 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
225 }
226
227 DataQuery dataQuery;
228 dataQuery.KeyPrefix(prefix);
229 dataQuery.DeviceId(deviceId_);
230 kvStore_->GetCount(dataQuery, sumGet);
231 EXPECT_EQ(sumGet, sum) << "count is not equal 10.";
232
233 std::vector<Entry> results;
234 kvStore_->GetEntries(dataQuery, results);
235 EXPECT_EQ(results.size(), sum) << "entries size is not equal 10.";
236
237 std::shared_ptr<KvStoreResultSet> resultSet;
238 Status status = kvStore_->GetResultSet(dataQuery, resultSet);
239 EXPECT_EQ(status, Status::SUCCESS);
240 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 10.";
241 resultSet->IsFirst();
242 resultSet->IsAfterLast();
243 resultSet->IsBeforeFirst();
244 resultSet->MoveToPosition(1);
245 resultSet->IsLast();
246 resultSet->MoveToPrevious();
247 resultSet->MoveToNext();
248 resultSet->MoveToLast();
249 resultSet->MoveToFirst();
250 resultSet->GetPosition();
251 Entry entry;
252 resultSet->GetEntry(entry);
253
254 for (size_t i = 0; i < sum; i++) {
255 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
256 }
257
258 status = kvStore_->CloseResultSet(resultSet);
259 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
260 }
261
262 /**
263 * @tc.name: GetPrefixQueryEntriesAndResultSet
264 * @tc.desc: get entries and result set by prefix query.
265 * @tc.type: FUNC
266 * @tc.require: I5DE2A
267 * @tc.author: Sven Wang
268 */
269 HWTEST_F(DeviceKvStoreTest, GetPrefixQueryEntriesAndResultSet, TestSize.Level1)
270 {
271 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
272 if (options_.baseDir.empty()) {
273 return;
274 }
275
276 // prepare 10
277 size_t sum = 10;
278 std::string prefix = "prefix_";
279 for (size_t i = 0; i < sum; i++) {
280 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
281 }
282
283 DataQuery dataQuery;
284 dataQuery.KeyPrefix(GetKey(prefix));
285 int sumGet = 0;
286 kvStore_->GetCount(dataQuery, sumGet);
287 EXPECT_EQ(sumGet, sum) << "count is not equal 10.";
288 dataQuery.Limit(10, 0);
289 std::vector<Entry> results;
290 kvStore_->GetEntries(dataQuery, results);
291 EXPECT_EQ(results.size(), sum) << "entries size is not equal 10.";
292
293 std::shared_ptr<KvStoreResultSet> resultSet;
294 Status status = kvStore_->GetResultSet(dataQuery, resultSet);
295 EXPECT_EQ(status, Status::SUCCESS);
296 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 10.";
297 resultSet->IsFirst();
298 resultSet->IsAfterLast();
299 resultSet->IsBeforeFirst();
300 resultSet->MoveToPosition(1);
301 resultSet->IsLast();
302 resultSet->MoveToPrevious();
303 resultSet->MoveToNext();
304 resultSet->MoveToLast();
305 resultSet->MoveToFirst();
306 resultSet->GetPosition();
307 Entry entry;
308 resultSet->GetEntry(entry);
309
310 for (size_t i = 0; i < sum; i++) {
311 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
312 }
313
314 status = kvStore_->CloseResultSet(resultSet);
315 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
316 }
317
318 /**
319 * @tc.name: GetInKeysQueryResultSet
320 * @tc.desc: get entries and result set by prefix query.
321 * @tc.type: FUNC
322 * @tc.require: I5DE2A
323 * @tc.author: Sven Wang
324 */
325 HWTEST_F(DeviceKvStoreTest, GetInKeysQueryResultSet, TestSize.Level1)
326 {
327 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
328 if (options_.baseDir.empty()) {
329 return;
330 }
331
332 // prepare 10
333 size_t sum = 10;
334
335 std::string prefix = "prefix_";
336 for (size_t i = 0; i < sum; i++) {
337 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
338 }
339
340 DataQuery dataQuery;
341 dataQuery.InKeys({"prefix_0", "prefix_1", "prefix_3", "prefix_9"});
342 int sumGet = 0;
343 kvStore_->GetCount(dataQuery, sumGet);
344 EXPECT_EQ(sumGet, 4) << "count is not equal 4.";
345 dataQuery.Limit(10, 0);
346 std::shared_ptr<KvStoreResultSet> resultSet;
347 Status status = kvStore_->GetResultSet(dataQuery, resultSet);
348 EXPECT_EQ(status, Status::SUCCESS);
349 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 4.";
350 resultSet->IsFirst();
351 resultSet->IsAfterLast();
352 resultSet->IsBeforeFirst();
353 resultSet->MoveToPosition(1);
354 resultSet->IsLast();
355 resultSet->MoveToPrevious();
356 resultSet->MoveToNext();
357 resultSet->MoveToLast();
358 resultSet->MoveToFirst();
359 resultSet->GetPosition();
360 Entry entry;
361 resultSet->GetEntry(entry);
362
363 for (size_t i = 0; i < sum; i++) {
364 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
365 }
366
367 status = kvStore_->CloseResultSet(resultSet);
368 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
369 }
370
371 /**
372 * @tc.name: GetPrefixEntriesAndResultSet
373 * @tc.desc: get entries and result set by prefix.
374 * @tc.type: FUNC
375 * @tc.require: I5DE2A
376 * @tc.author: Sven Wang
377 */
378 HWTEST_F(DeviceKvStoreTest, GetPrefixEntriesAndResultSet, TestSize.Level1)
379 {
380 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
381
382 // prepare 10
383 size_t sum = 10;
384 int sumGet = 10;
385 std::string prefix = "prefix_";
386 for (size_t i = 0; i < sum; i++) {
387 kvStore_->Put({prefix + std::to_string(i)}, {std::to_string(i)});
388 }
389 std::vector<Entry> results;
390 kvStore_->GetEntries(GetKey(prefix + " "), results);
391 EXPECT_EQ(results.size(), sum) << "entries size is not equal 10.";
392
393 std::shared_ptr<KvStoreResultSet> resultSet;
394 Status status = kvStore_->GetResultSet({ GetKey(std::string(" ") + prefix + " ") }, resultSet);
395 EXPECT_EQ(status, Status::SUCCESS);
396 EXPECT_EQ(resultSet->GetCount(), sumGet) << "resultSet size is not equal 10.";
397 resultSet->IsFirst();
398 resultSet->IsAfterLast();
399 resultSet->IsBeforeFirst();
400 resultSet->MoveToPosition(1);
401 resultSet->IsLast();
402 resultSet->MoveToPrevious();
403 resultSet->MoveToNext();
404 resultSet->MoveToLast();
405 resultSet->MoveToFirst();
406 resultSet->GetPosition();
407 Entry entry;
408 resultSet->GetEntry(entry);
409
410 for (size_t i = 0; i < sum; i++) {
411 kvStore_->Delete({GetKey(prefix + std::to_string(i))});
412 }
413
414 status = kvStore_->CloseResultSet(resultSet);
415 EXPECT_EQ(status, Status::SUCCESS) << "Close resultSet failed.";
416 }
417
418 /**
419 * @tc.name: Subscribe001
420 * @tc.desc: Put data and get callback.
421 * @tc.type: FUNC
422 * @tc.require: I5DE2A
423 * @tc.author: Sven Wang
424 */
425 HWTEST_F(DeviceKvStoreTest, Subscribe001, TestSize.Level1)
426 {
427 auto observer = std::make_shared<DeviceObserverTestImpl>();
428 auto subStatus = kvStore_->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer);
429 EXPECT_EQ(subStatus, Status::SUCCESS) << "Subscribe observer failed.";
430 // subscribe repeated observer;
431 auto repeatedSubStatus = kvStore_->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer);
432 EXPECT_NE(repeatedSubStatus, Status::SUCCESS) << "Repeat subscribe kvStore observer failed.";
433
434 auto unSubStatus = kvStore_->UnSubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer);
435 EXPECT_EQ(unSubStatus, Status::SUCCESS) << "Unsubscribe observer failed.";
436 }
437
438 /**
439 * @tc.name: SyncCallback001
440 * @tc.desc: Register sync callback.
441 * @tc.type: FUNC
442 * @tc.require: I5DE2A
443 * @tc.author: Sven Wang
444 */
445 HWTEST_F(DeviceKvStoreTest, SyncCallback001, TestSize.Level1)
446 {
447 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
448
449 auto syncCallback = std::make_shared<DeviceSyncCallbackTestImpl>();
450 auto syncStatus = kvStore_->RegisterSyncCallback(syncCallback);
451 EXPECT_EQ(syncStatus, Status::SUCCESS) << "Register sync callback failed.";
452
453 auto unRegStatus = kvStore_->UnRegisterSyncCallback();
454 EXPECT_EQ(unRegStatus, Status::SUCCESS) << "Unregister sync callback failed.";
455
456 Key skey = {"single_001"};
457 Value sval = {"value_001"};
458 kvStore_->Put(skey, sval);
459 kvStore_->Delete(skey);
460
461 std::map<std::string, Status> results;
462 results.insert({"aaa", Status::INVALID_ARGUMENT});
463 syncCallback->SyncCompleted(results);
464 }
465
466 /**
467 * @tc.name: RemoveDeviceData001
468 * @tc.desc: Remove device data.
469 * @tc.type: FUNC
470 * @tc.require: I5DE2A
471 * @tc.author: Sven Wang
472 */
473 HWTEST_F(DeviceKvStoreTest, RemoveDeviceData001, TestSize.Level1)
474 {
475 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
476
477 Key skey = {"single_001"};
478 Value sval = {"value_001"};
479 kvStore_->Put(skey, sval);
480
481 std::string deviceId = "no_exist_device_id";
482 auto removeStatus = kvStore_->RemoveDeviceData(deviceId);
483 EXPECT_NE(removeStatus, Status::SUCCESS) << "Remove device should not return success";
484
485 Value retVal;
486 auto getRet = kvStore_->Get(GetKey(skey.ToString()), retVal);
487 EXPECT_EQ(getRet, Status::SUCCESS) << "Get value failed.";
488 EXPECT_EQ(retVal.Size(), sval.Size()) << "data base should be null.";
489 }
490
491 /**
492 * @tc.name: SyncData001
493 * @tc.desc: Synchronize device data.
494 * @tc.type: FUNC
495 * @tc.require: I5DE2A
496 * @tc.author: Sven Wang
497 */
498 HWTEST_F(DeviceKvStoreTest, SyncData001, TestSize.Level1)
499 {
500 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
501 std::string deviceId = "no_exist_device_id";
502 std::vector<std::string> deviceIds = { deviceId };
503 auto syncStatus = kvStore_->Sync(deviceIds, SyncMode::PUSH);
504 EXPECT_NE(syncStatus, Status::SUCCESS) << "Sync device should not return success";
505 }
506
507 /**
508 * @tc.name: TestSchemaStoreC001
509 * @tc.desc: Test schema device store.
510 * @tc.type: FUNC
511 * @tc.require: I5DE2A
512 * @tc.author: Sven Wang
513 */
514 HWTEST_F(DeviceKvStoreTest, TestSchemaStoreC001, TestSize.Level1)
515 {
516 std::shared_ptr<SingleKvStore> deviceKvStore;
517 DistributedKvDataManager manager;
518 Options options;
519 options.encrypt = true;
520 options.securityLevel = S1;
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.securityLevel = S1;
1184 options.area = EL1;
1185 options.baseDir = std::string("/data/service/el1/public/database/odmf");
1186 AppId appId = { "odmf" };
1187 StoreId storeId = { "schema_device_id001" };
1188 manager.GetSingleKvStore(options, appId, storeId, kvStore);
1189 ASSERT_NE(kvStore, nullptr) << "kvStore is null.";
1190 auto result = kvStore->GetStoreId();
1191 EXPECT_EQ(result.storeId, "schema_device_id001");
1192
1193 auto testStatus = kvStore->SetCapabilityEnabled(true);
1194 EXPECT_EQ(testStatus, Status::SUCCESS) << "set fail";
1195 manager.DeleteKvStore(appId, storeId, options.baseDir);
1196 }
1197
1198 /**
1199 * @tc.name: DeviceSync002
1200 * @tc.desc: Test sync enable.
1201 * @tc.type: FUNC
1202 * @tc.require: I5DE2A
1203 * @tc.author: Sven Wang
1204 */
1205 HWTEST_F(DeviceKvStoreTest, DeviceSync002, TestSize.Level1)
1206 {
1207 std::shared_ptr<SingleKvStore> kvStore;
1208 DistributedKvDataManager manager;
1209 Options options;
1210 options.encrypt = true;
1211 options.securityLevel = S1;
1212 options.area = EL1;
1213 options.baseDir = std::string("/data/service/el1/public/database/odmf");
1214 AppId appId = { "odmf" };
1215 StoreId storeId = { "schema_device_id002" };
1216 manager.GetSingleKvStore(options, appId, storeId, kvStore);
1217 ASSERT_NE(kvStore, nullptr) << "kvStore is null.";
1218 auto result = kvStore->GetStoreId();
1219 EXPECT_EQ(result.storeId, "schema_device_id002");
1220
1221 std::vector<std::string> local = {"A", "B"};
1222 std::vector<std::string> remote = {"C", "D"};
1223 auto testStatus = kvStore->SetCapabilityRange(local, remote);
1224 EXPECT_EQ(testStatus, Status::SUCCESS) << "set range fail";
1225 manager.DeleteKvStore(appId, storeId, options.baseDir);
1226 }
1227
1228 /**
1229 * @tc.name: SyncWithCondition001
1230 * @tc.desc: sync device data with condition;
1231 * @tc.type: FUNC
1232 * @tc.require: I5DE2A
1233 * @tc.author: Sven Wang
1234 */
1235 HWTEST_F(DeviceKvStoreTest, SyncWithCondition001, TestSize.Level1)
1236 {
1237 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
1238 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1239 DataQuery dataQuery;
1240 dataQuery.KeyPrefix("name");
1241 auto syncStatus = kvStore_->Sync(deviceIds, SyncMode::PUSH, dataQuery, nullptr);
1242 EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success";
1243 }
1244
1245 /**
1246 * @tc.name: SyncWithCondition002
1247 * @tc.desc: sync device data with condition;
1248 * @tc.type: FUNC
1249 * @tc.require:
1250 * @tc.author: SQL
1251 */
1252 HWTEST_F(DeviceKvStoreTest, SyncWithCondition002, TestSize.Level1)
1253 {
1254 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
1255 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1256 DataQuery dataQuery;
1257 dataQuery.KeyPrefix("name");
1258 uint32_t delay = 0;
1259 auto syncStatus = kvStore_->Sync(deviceIds, SyncMode::PUSH, dataQuery, nullptr, delay);
1260 EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success";
1261 }
1262
1263 /**
1264 * @tc.name: SubscribeWithQuery001
1265 * desc: subscribe and sync device data with query;
1266 * type: FUNC
1267 * @tc.require: I5DE2A
1268 * @tc.author: Sven Wang
1269 */
1270 HWTEST_F(DeviceKvStoreTest, SubscribeWithQuery001, TestSize.Level1)
1271 {
1272 EXPECT_NE(kvStore_, nullptr) << "kvStore is null.";
1273 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1274 DataQuery dataQuery;
1275 dataQuery.KeyPrefix("name");
1276 auto syncStatus = kvStore_->SubscribeWithQuery(deviceIds, dataQuery);
1277 EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success";
1278 }
1279
1280 /**
1281 * @tc.name: UnSubscribeWithQuery001
1282 * desc: subscribe and sync device data with query;
1283 * type: FUNC
1284 * @tc.require: I5DE2A
1285 * @tc.author: Sven Wang
1286 */
1287 HWTEST_F(DeviceKvStoreTest, UnSubscribeWithQuery001, TestSize.Level1)
1288 {
1289 EXPECT_NE(kvStore_, nullptr) << "kvStore is nullptr.";
1290 std::vector<std::string> deviceIds = {"invalid_device_id1", "invalid_device_id2"};
1291 DataQuery dataQuery;
1292 dataQuery.KeyPrefix("name");
1293 auto unSubscribeStatus = kvStore_->UnsubscribeWithQuery(deviceIds, dataQuery);
1294 EXPECT_NE(unSubscribeStatus, Status::SUCCESS) << "sync device should not return success";
1295 }
1296 } // namespace OHOS::Test