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