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