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