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