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 #include <gtest/gtest.h>
16 #include <ctime>
17 #include <cmath>
18 #include <thread>
19 #include <condition_variable>
20 #include <mutex>
21 #include <string>
22
23 #include "delegate_kv_mgr_callback.h"
24 #include "distributeddb_data_generator.h"
25 #include "distributed_test_tools.h"
26 #include "kv_store_delegate.h"
27 #include "kv_store_delegate_manager.h"
28 #include "distributed_test_sysinfo.h"
29
30 using namespace std;
31 using namespace testing;
32 #if defined TESTCASES_USING_GTEST_EXT
33 using namespace testing::ext;
34 #endif
35 using namespace DistributedDB;
36 using namespace DistributedDBDataGenerator;
37
38 namespace DistributeddbKvCreate {
39 const int OPER_CNT = 4;
40 DistributedDB::CipherPassword g_passwd1;
41 DistributedDB::CipherPassword g_passwd2;
42 class DistributeddbKvCreateTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase(void)50 void DistributeddbKvCreateTest::SetUpTestCase(void)
51 {
52 (void)g_passwd1.SetValue(PASSWD_VECTOR_1.data(), PASSWD_VECTOR_1.size());
53 (void)g_passwd2.SetValue(PASSWD_VECTOR_2.data(), PASSWD_VECTOR_2.size());
54 }
55
TearDownTestCase(void)56 void DistributeddbKvCreateTest::TearDownTestCase(void)
57 {
58 }
59
SetUp(void)60 void DistributeddbKvCreateTest::SetUp(void)
61 {
62 UnitTest *test = UnitTest::GetInstance();
63 ASSERT_NE(test, nullptr);
64 const TestInfo *testinfo = test->current_test_info();
65 ASSERT_NE(testinfo, nullptr);
66 string testCaseName = string(testinfo->name());
67 MST_LOG("[SetUp] test case %s is start to run", testCaseName.c_str());
68 }
69
TearDown(void)70 void DistributeddbKvCreateTest::TearDown(void)
71 {
72 }
73
74 /*
75 * @tc.name: Open 001
76 * @tc.desc: Verify that the kv db was created successfully.
77 * @tc.type: FUNC
78 * @tc.require: SR000CQS3O
79 * @tc.author: luqianfu
80 */
81 HWTEST_F(DistributeddbKvCreateTest, Open001, TestSize.Level1)
82 {
83 KvStoreDelegateManager *manager1 = nullptr;
84 KvStoreDelegateManager *manager2 = nullptr;
85 KvStoreDelegateManager *manager3 = nullptr;
86 KvStoreDelegateManager *manager4 = nullptr;
87
88 /**
89 * @tc.steps: step1. create kv db with params storeId1, appId1, userId1.
90 * @tc.expected: step1. the kv db was created successfully.
91 */
92 KvStoreDelegate *result = nullptr;
93 result = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1, g_kvOption);
94 ASSERT_TRUE(manager1 != nullptr && result != nullptr);
95 EXPECT_TRUE(manager1->CloseKvStore(result) == OK);
96 result = nullptr;
97 /**
98 * @tc.steps: step2. create kv db with params storeId2, appId1, userId1.
99 * @tc.expected: step2. the kv db was created successfully.
100 */
101 result = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter2_1_1, g_kvOption);
102 ASSERT_TRUE(manager2 != nullptr && result != nullptr);
103 EXPECT_TRUE(manager2->CloseKvStore(result) == OK);
104 result = nullptr;
105 /**
106 * @tc.steps: step3. create kv db with params storeId1, appId2, userId1.
107 * @tc.expected: step3. the kv db was created successfully.
108 */
109 result = DistributedTestTools::GetDelegateSuccess(manager3, g_kvdbParameter1_2_1, g_kvOption);
110 ASSERT_TRUE(manager3 != nullptr && result != nullptr);
111 EXPECT_TRUE(manager3->CloseKvStore(result) == OK);
112 result = nullptr;
113 /**
114 * @tc.steps: step4. create kv db with params storeId1, appId1, userId2.
115 * @tc.expected: step4. the kv db was created successfully.
116 */
117 result = DistributedTestTools::GetDelegateSuccess(manager4, g_kvdbParameter1_1_2, g_kvOption);
118 ASSERT_TRUE(manager4 != nullptr && result != nullptr);
119 EXPECT_EQ(manager4->CloseKvStore(result), OK);
120 result = nullptr;
121
122 EXPECT_EQ(manager1->DeleteKvStore(STORE_ID_1), OK);
123 delete manager1;
124 manager1 = nullptr;
125 EXPECT_EQ(manager2->DeleteKvStore(STORE_ID_2), OK);
126 delete manager2;
127 manager2 = nullptr;
128 EXPECT_EQ(manager3->DeleteKvStore(STORE_ID_1), OK);
129 delete manager3;
130 manager3 = nullptr;
131 EXPECT_EQ(manager4->DeleteKvStore(STORE_ID_1), OK);
132 delete manager4;
133 manager4 = nullptr;
134 }
135
136 /*
137 * @tc.name: Open 002
138 * @tc.desc: Verify that the kv db can be reopened successfully
139 * @tc.type: FUNC
140 * @tc.require: SR000CQS3O
141 * @tc.author: luqianfu
142 */
143 HWTEST_F(DistributeddbKvCreateTest, Open002, TestSize.Level1)
144 {
145 KvStoreDelegate *result = nullptr;
146 KvStoreDelegateManager *manager = nullptr;
147 /**
148 * @tc.steps: step1. create kv db.
149 * @tc.expected: step1. the kv db was created successfully.
150 */
151 KvOption option = g_kvOption;
152 option.localOnly = IS_LOCAL_ONLY;
153 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
154 ASSERT_TRUE(manager != nullptr && result != nullptr);
155 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
156 delete manager;
157 manager = nullptr;
158 /**
159 * @tc.steps: step2. reopen kv db.
160 * @tc.expected: step2. the kv db was reopened successfully.
161 */
162 option.createIfNecessary = IS_NOT_NEED_CREATE;
163 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
164 ASSERT_TRUE(manager != nullptr && result != nullptr);
165
166 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
167 result = nullptr;
168 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
169 delete manager;
170 manager = nullptr;
171 }
172
173 /*
174 * @tc.name: Open 003
175 * @tc.desc: Verify that can not reopen an absent db.
176 * @tc.type: FUNC
177 * @tc.require: SR000CQS3O
178 * @tc.author: luqianfu
179 */
180 HWTEST_F(DistributeddbKvCreateTest, Open003, TestSize.Level1)
181 {
182 /**
183 * @tc.steps: step1. delete kv db if exist.
184 * @tc.expected: step1. Construct that no database exist.
185 */
186 KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
187 ASSERT_NE(manager, nullptr);
188 SetDir(DIRECTOR);
189 DBStatus status = manager->SetKvStoreConfig(KV_CONFIG);
190 EXPECT_EQ(status, DBStatus::OK);
191 status = manager->DeleteKvStore(STORE_ID_1);
192 EXPECT_EQ(status, DBStatus::NOT_FOUND);
193 delete manager;
194 manager = nullptr;
195
196 KvStoreDelegate *delegate = nullptr;
197 /**
198 * @tc.steps: step2. reopen an absent db.
199 * @tc.expected: step2. reopen failed and return error.
200 */
201 KvOption option = g_kvOption;
202 option.createIfNecessary = IS_NOT_NEED_CREATE;
203 option.localOnly = IS_LOCAL_ONLY;
204 status = DistributedTestTools::GetDelegateNotGood(manager, delegate, STORE_ID_1, APP_ID_1, USER_ID_1, option);
205 ASSERT_NE(status, DBStatus::OK);
206 EXPECT_EQ(delegate, nullptr);
207 EXPECT_EQ(manager->CloseKvStore(delegate), INVALID_ARGS);
208
209 delete manager;
210 manager = nullptr;
211 }
212
213 /*
214 * @tc.name: Open 004
215 * @tc.desc: Verify that transferring param IS_NOT_NEED_CREATE can not create kv db.
216 * @tc.type: FUNC
217 * @tc.require: SR000BUH3J
218 * @tc.author: luqianfu
219 */
220 HWTEST_F(DistributeddbKvCreateTest, Open004, TestSize.Level1)
221 {
222 KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_2);
223 ASSERT_NE(manager, nullptr);
224 SetDir(DIRECTOR);
225 EXPECT_EQ(manager->SetKvStoreConfig(KV_CONFIG), DBStatus::OK);
226 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::NOT_FOUND);
227
228 KvStoreDelegateManager *manager1 = nullptr;
229 KvStoreDelegateManager *manager2 = nullptr;
230 /**
231 * @tc.steps: step1. create kv db with param IS_NOT_NEED_CREATE.
232 * @tc.expected: step1. create kv db and close it failed.
233 */
234 KvOption option = g_kvOption;
235 option.createIfNecessary = IS_NOT_NEED_CREATE;
236 KvStoreDelegate *result1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1_1_2, option);
237 EXPECT_TRUE(manager1 == nullptr && result1 == nullptr);
238 EXPECT_TRUE(manager->CloseKvStore(result1) != OK);
239 delete manager;
240 manager = nullptr;
241
242 /**
243 * @tc.steps: step2. create kv db with param IS_NEED_CREATE.
244 * @tc.expected: step2. create kv db and close it successfully.
245 */
246 KvStoreDelegate *result2 = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter1_1_2,
247 g_kvOption);
248 ASSERT_TRUE(manager2 != nullptr && result2 != nullptr);
249 EXPECT_TRUE(manager2->CloseKvStore(result2) == OK);
250 result2 = nullptr;
251 EXPECT_TRUE(manager2->DeleteKvStore(STORE_ID_1) == OK);
252 delete manager2;
253 manager2 = nullptr;
254 }
255
256 /*
257 * @tc.name: Open 005
258 * @tc.desc: Verify that can not create or open kv db with exceptional params.
259 * @tc.type: EXCEPTION
260 * @tc.require: SR000BUH3J
261 * @tc.author: luqianfu
262 */
263 HWTEST_F(DistributeddbKvCreateTest, Open005, TestSize.Level1)
264 {
265 KvStoreDelegateManager *manager1 = nullptr;
266 KvStoreDelegateManager *manager2 = nullptr;
267 KvStoreDelegateManager *manager3 = nullptr;
268 KvStoreDelegateManager *manager4 = nullptr;
269 KvStoreDelegate *delegate1 = nullptr;
270 KvStoreDelegate *delegate2 = nullptr;
271 KvStoreDelegate *delegate3 = nullptr;
272 KvStoreDelegate *delegate4 = nullptr;
273
274 /**
275 * @tc.steps: step1. create kv db with param storeId is null.
276 * @tc.expected: step1. create kv db failed.
277 */
278 KvOption option1 = g_kvOption;
279 option1.createIfNecessary = IS_NEED_CREATE;
280 option1.localOnly = IS_LOCAL_ONLY;
281 DBStatus status = DistributedTestTools::GetDelegateNotGood(manager1, delegate1, "", APP_ID_1, USER_ID_1, option1);
282 ASSERT_EQ(status, DBStatus::INVALID_ARGS);
283 EXPECT_TRUE(delegate1 == nullptr);
284 EXPECT_TRUE(manager1->CloseKvStore(delegate1) == INVALID_ARGS);
285
286 /**
287 * @tc.steps: step2. create kv db with param appId is null.
288 * @tc.expected: step2. create kv db failed.
289 */
290 KvOption option2 = g_kvOption;
291 option2.createIfNecessary = IS_NEED_CREATE;
292 option2.localOnly = IS_LOCAL_ONLY;
293 status = DistributedTestTools::GetDelegateNotGood(manager2, delegate2, STORE_ID_1, "", USER_ID_1, option2);
294 ASSERT_EQ(status, DBStatus::INVALID_ARGS);
295 EXPECT_TRUE(delegate2 == nullptr);
296 EXPECT_TRUE(manager2->CloseKvStore(delegate2) == INVALID_ARGS);
297
298 /**
299 * @tc.steps: step3. create kv db with param userId is null.
300 * @tc.expected: step3. create kv db failed.
301 */
302 KvOption option3 = g_kvOption;
303 option3.createIfNecessary = IS_NEED_CREATE;
304 option3.localOnly = IS_LOCAL_ONLY;
305 status = DistributedTestTools::GetDelegateNotGood(manager3, delegate3, STORE_ID_1, APP_ID_1, "", option3);
306 ASSERT_EQ(status, DBStatus::INVALID_ARGS);
307 EXPECT_TRUE(delegate3 == nullptr);
308 EXPECT_TRUE(manager3->CloseKvStore(delegate3) == INVALID_ARGS);
309
310 /**
311 * @tc.steps: step3. create kv db with param userId is null.
312 * @tc.expected: step3. create kv db failed.
313 */
314 KvOption option4 = g_kvOption;
315 option4.createIfNecessary = IS_NOT_NEED_CREATE;
316 option4.localOnly = IS_LOCAL_ONLY;
317 status = DistributedTestTools::GetDelegateNotGood(manager4, delegate4, STORE_ID_1, APP_ID_1, USER_ID_1, option4);
318 ASSERT_NE(status, DBStatus::OK);
319 EXPECT_TRUE(delegate4 == nullptr);
320 EXPECT_TRUE(manager4->CloseKvStore(delegate4) == INVALID_ARGS);
321
322 delete manager1;
323 manager1 = nullptr;
324 delete manager2;
325 manager2 = nullptr;
326 delete manager3;
327 manager3 = nullptr;
328 delete manager4;
329 manager4 = nullptr;
330 }
331
332 /*
333 * @tc.name: Close 001
334 * @tc.desc: Verify that can close kv db successfully.
335 * @tc.type: FUNC
336 * @tc.require: SR000BUH3J
337 * @tc.author: luqianfu
338 */
339 HWTEST_F(DistributeddbKvCreateTest, Close001, TestSize.Level1)
340 {
341 KvStoreDelegate *result = nullptr;
342 KvStoreDelegateManager *manager = nullptr;
343
344 /**
345 * @tc.steps: step1. create and open kv db.
346 * @tc.expected: step1. create and open kv db successfully.
347 */
348 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
349 ASSERT_TRUE(manager != nullptr && result != nullptr);
350
351 /**
352 * @tc.steps: step2. close kv db that exist.
353 * @tc.expected: step2. close kv db successfully.
354 */
355 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
356 result = nullptr;
357 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
358 delete manager;
359 manager = nullptr;
360 }
361
362 /*
363 * @tc.name: Close 002
364 * @tc.desc: Verify that can not close absent db successfully.
365 * @tc.type: FUNC
366 * @tc.require: SR000BUH3J
367 * @tc.author: luqianfu
368 */
369 HWTEST_F(DistributeddbKvCreateTest, Close002, TestSize.Level1)
370 {
371 KvStoreDelegate *result = nullptr;
372 KvStoreDelegateManager *manager = nullptr;
373
374 /**
375 * @tc.steps: step1. create and delete kv db.
376 * @tc.expected: step1. Construct that no database exist.
377 */
378 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
379 ASSERT_TRUE(manager != nullptr && result != nullptr);
380 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
381 result = nullptr;
382
383 /**
384 * @tc.steps: step2. close nonexistent db.
385 * @tc.expected: step2. close db failed.
386 */
387 EXPECT_EQ(manager->CloseKvStore(result), INVALID_ARGS);
388
389 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
390 delete manager;
391 manager = nullptr;
392 }
393
394 /*
395 * @tc.name: Delete 001
396 * @tc.desc: Verify that can delete db successfully.
397 * @tc.type: FUNC
398 * @tc.require: SR000BUH3J
399 * @tc.author: luqianfu
400 */
401 HWTEST_F(DistributeddbKvCreateTest, Delete001, TestSize.Level1)
402 {
403 KvStoreDelegate *result = nullptr;
404 KvStoreDelegateManager *manager = nullptr;
405
406 /**
407 * @tc.steps: step1. create and close kv db.
408 * @tc.expected: step1. Construct that database exist.
409 */
410 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
411 ASSERT_TRUE(manager != nullptr && result != nullptr);
412 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
413 result = nullptr;
414 /**
415 * @tc.steps: step2. delete db.
416 * @tc.expected: step2. delete db successfully.
417 */
418 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
419
420 delete manager;
421 manager = nullptr;
422 }
423
424 /*
425 * @tc.name: Delete 002
426 * @tc.desc: Verify that can not delete absent db.
427 * @tc.type: FUNC
428 * @tc.require: SR000BUH3J
429 * @tc.author: luqianfu
430 */
431 HWTEST_F(DistributeddbKvCreateTest, Delete002, TestSize.Level1)
432 {
433 KvStoreDelegate *result = nullptr;
434 KvStoreDelegateManager *manager = nullptr;
435
436 /**
437 * @tc.steps: step1. create and delete kv db.
438 * @tc.expected: step1. Construct that no database exist.
439 */
440 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
441 ASSERT_TRUE(manager != nullptr && result != nullptr);
442 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
443 result = nullptr;
444 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
445
446 /**
447 * @tc.steps: step2. delete absent db.
448 * @tc.expected: step2. delete absent db failed.
449 */
450 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == NOT_FOUND);
451
452 delete manager;
453 manager = nullptr;
454 }
455
456 /*
457 * @tc.name: Config 001
458 * @tc.desc: Verify that can set global config of db.
459 * @tc.type: FUNC
460 * @tc.require: SR000BUH3J
461 * @tc.author: luqianfu
462 */
463 HWTEST_F(DistributeddbKvCreateTest, Config001, TestSize.Level1)
464 {
465 KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
466 ASSERT_NE(manager, nullptr);
467 /**
468 * @tc.steps: step1. set rightly exist global config of db.
469 * @tc.expected: step1. set successfully.
470 */
471 SetDir(DIRECTOR);
472 KvStoreConfig config;
473 config.dataDir = DIRECTOR;
474 EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
475 /**
476 * @tc.steps: step2. set exceptionally not exist global config of db.
477 * @tc.expected: step2. set failed.
478 */
479 config.dataDir = "/dataDED/";
480 EXPECT_EQ(manager->SetKvStoreConfig(config), INVALID_ARGS);
481 delete manager;
482 manager = nullptr;
483 }
484
485 /*
486 * @tc.name: Config 002
487 * @tc.desc: Verify that can get the set storeid and check it.
488 * @tc.type: FUNC
489 * @tc.require: SR000BUH3J
490 * @tc.author: luqianfu
491 */
492 HWTEST_F(DistributeddbKvCreateTest, Config002, TestSize.Level1)
493 {
494 KvStoreDelegate *result = nullptr;
495 KvStoreDelegateManager *manager = nullptr;
496 /**
497 * @tc.steps: step1. create kv db with STORE_ID_1.
498 * @tc.expected: step1. create db successfully.
499 */
500 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
501 ASSERT_TRUE(manager != nullptr && result != nullptr);
502
503 /**
504 * @tc.steps: step2. get the set storeid of db.
505 * @tc.expected: step2. get the set storeid successfully and it equals STORE_ID_1.
506 */
507 string storeid = result->GetStoreId();
508 ASSERT_STREQ(STORE_ID_1.c_str(), storeid.c_str());
509
510 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
511 result = nullptr;
512 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
513 delete manager;
514 manager = nullptr;
515 }
516
517 /*
518 * @tc.name: Performance 001
519 * @tc.desc: calculate the time of creating db.
520 * @tc.type: Performance
521 * @tc.require: SR000BUH3J
522 * @tc.author: luqianfu
523 */
524 HWTEST_F(DistributeddbKvCreateTest, Performance001, TestSize.Level2)
525 {
526 std::chrono::steady_clock::time_point tick, tock;
527 /**
528 * @tc.steps: step1. get the time1 and then create kv db.
529 * @tc.expected: step1. create kv db successfully.
530 */
531 SetDir(DIRECTOR);
532 DelegateKvMgrCallback delegateKvMgrCallback;
533 function<void(DBStatus, KvStoreDelegate*)> function
534 = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
535
536 KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
537 ASSERT_NE(manager, nullptr);
538 EXPECT_EQ(manager->SetKvStoreConfig(KV_CONFIG), DBStatus::OK);
539 KvStoreDelegate::Option option = DistributedTestTools::TransferKvOptionType(g_kvOption);
540
541 tick = std::chrono::steady_clock::now();
542 manager->GetKvStore(STORE_ID_1, option, function);
543 tock = std::chrono::steady_clock::now();
544
545 KvStoreDelegate* delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
546 EXPECT_NE(delegate, nullptr);
547 /**
548 * @tc.steps: step2. get the time2 after creating kv db.
549 * @tc.expected: step2. time2-time1<100s.
550 */
551 std::chrono::duration<uint64_t, std::milli> dur;
552 dur = std::chrono::duration_cast<std::chrono::milliseconds>(tock - tick);
553 double duration = static_cast<double>(dur.count());
554 MST_LOG("the time used for create DB is %f ms", duration);
555
556 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
557 delegate = nullptr;
558 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
559 delete manager;
560 manager = nullptr;
561 }
562
563 /*
564 * @tc.name: Performance 002
565 * @tc.desc: check the system or cpu storage and power when creating db.
566 * @tc.type: Performance
567 * @tc.require: SR000BUH3J
568 * @tc.author: luqianfu
569 */
570 HWTEST_F(DistributeddbKvCreateTest, Performance002, TestSize.Level2)
571 {
572 /**
573 * @tc.steps: step1. get the system info before creating db.
574 * @tc.expected: step1. the system or cpu storage and power is normal.
575 */
576 DistributedTestSysInfo si;
577 MST_LOG("System info before opening db");
578 si.GetSysMemOccpy(FIRST);
579 si.GetSysCpuUsage(FIRST, DEFAULT_INTEVAL);
580 si.GetSysCurrentPower(FIRST, DEFAULT_COUNT, DEFAULT_INTEVAL);
581
582 /**
583 * @tc.steps: step2. construct the params for interface and create db
584 * @tc.expected: step2. create db successfully.
585 */
586 KvStoreDelegate *result = nullptr;
587 KvStoreDelegateManager *manager = nullptr;
588 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
589 ASSERT_TRUE(manager != nullptr && result != nullptr);
590
591 /**
592 * @tc.steps: step3. get the system info after creating db.
593 * @tc.expected: step3. the system or cpu storage and power is normal.
594 */
595 MST_LOG("System info after opening db");
596 si.GetSysMemOccpy(SECOND);
597 si.GetSysCpuUsage(SECOND, DEFAULT_INTEVAL);
598 si.GetSysCurrentPower(SECOND, DEFAULT_COUNT, DEFAULT_INTEVAL);
599
600 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
601 result = nullptr;
602 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
603 delete manager;
604 manager = nullptr;
605 }
606
607 /*
608 * @tc.name: Performance 003
609 * @tc.desc: calculate the time of reopening db.
610 * @tc.type: Performance
611 * @tc.require: SR000BUH3J
612 * @tc.author: luqianfu
613 */
614 HWTEST_F(DistributeddbKvCreateTest, Performance003, TestSize.Level2)
615 {
616 KvStoreDelegate *delegate = nullptr;
617 KvStoreDelegateManager *manager = nullptr;
618 /**
619 * @tc.steps: step1. create and close kv db.
620 * @tc.expected: step1. Construct that database exist.
621 */
622 KvOption option = g_kvOption;
623 option.localOnly = IS_LOCAL_ONLY;
624 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
625 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
626 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
627 delegate = nullptr;
628
629 DelegateKvMgrCallback delegateKvMgrCallback;
630 function<void(DBStatus, KvStoreDelegate*)> function
631 = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
632 std::chrono::steady_clock::time_point tick, tock;
633 option.createIfNecessary = IS_NOT_NEED_CREATE;
634 /**
635 * @tc.steps: step2. get the tick and tock value of the system before and after reopen the db.
636 * @tc.expected: step2. the system time of tick and tock obtained successfully.
637 */
638 KvStoreDelegate::Option optionUsedForGetStore = DistributedTestTools::TransferKvOptionType(option);
639 tick = std::chrono::steady_clock::now();
640 manager->GetKvStore(STORE_ID_1, optionUsedForGetStore, function);
641 tock = std::chrono::steady_clock::now();
642
643 /**
644 * @tc.steps: step3. tock - tick and translate it to milliseconds.
645 * @tc.expected: step3. tock - tick < 150ms.
646 */
647 std::chrono::duration<uint64_t, std::milli> dur;
648 dur = std::chrono::duration_cast<std::chrono::milliseconds>(tock - tick);
649 double duration = static_cast<double>(dur.count());
650 MST_LOG("the time used for reopen DB is %f ms", duration);
651
652 delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
653 EXPECT_NE(delegate, nullptr);
654
655 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
656 delegate = nullptr;
657 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
658 delete manager;
659 manager = nullptr;
660 }
661
662 /*
663 * @tc.name: Performance 004
664 * @tc.desc: check the system or cpu storage and power when reopening db.
665 * @tc.type: System overhead
666 * @tc.require: SR000BUH3J
667 * @tc.author: luqianfu
668 */
669 HWTEST_F(DistributeddbKvCreateTest, Performance004, TestSize.Level3)
670 {
671 KvStoreDelegate *delegate = nullptr;
672 KvStoreDelegateManager *manager = nullptr;
673 /**
674 * @tc.steps: step1. create and close kv db.
675 * @tc.expected: step1. Construct that database exist.
676 */
677 KvOption option04 = g_kvOption;
678 option04.localOnly = IS_LOCAL_ONLY;
679 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option04);
680 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
681 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
682 delegate = nullptr;
683 delete manager;
684 manager = nullptr;
685
686 /**
687 * @tc.steps: step2. get the system info before reopening db and then reopen db.
688 * @tc.expected: step2. the system or cpu storage and power is normal and reopen db successful .
689 */
690 MST_LOG("System info before reopening db");
691 DistributedTestSysInfo sysInfo04;
692 sysInfo04.GetSysMemOccpy(FIRST);
693 sysInfo04.GetSysCpuUsage(FIRST, DEFAULT_INTEVAL);
694 sysInfo04.GetSysCurrentPower(FIRST, DEFAULT_COUNT, DEFAULT_INTEVAL);
695 option04.createIfNecessary = IS_NOT_NEED_CREATE;
696 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option04);
697 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
698
699 /**
700 * @tc.steps: step3. get the system info after reopening db.
701 * @tc.expected: step3. the system or cpu storage and power is normal and reopen db successful.
702 */
703 MST_LOG("System info after reopening db");
704 sysInfo04.GetSysMemOccpy(SECOND);
705 sysInfo04.GetSysCpuUsage(SECOND, DEFAULT_INTEVAL);
706 sysInfo04.GetSysCurrentPower(SECOND, DEFAULT_COUNT, DEFAULT_INTEVAL);
707
708 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
709 delegate = nullptr;
710 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
711 delete manager;
712 manager = nullptr;
713 }
714
715 /*
716 * @tc.name: Performance 005
717 * @tc.desc: check the system storage when reopening by reopening db.
718 * @tc.type: System overhead
719 * @tc.require: SR000BUH3J
720 * @tc.author: luqianfu
721 */
722 HWTEST_F(DistributeddbKvCreateTest, Performance005, TestSize.Level3)
723 {
724 KvStoreDelegate *delegate = nullptr;
725 KvStoreDelegateManager *manager = nullptr;
726 /**
727 * @tc.steps: step1. create and close kv db.
728 * @tc.expected: step1. Construct that database exist.
729 */
730 KvOption option05 = g_kvOption;
731 option05.localOnly = IS_LOCAL_ONLY;
732 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option05);
733 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
734 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
735 delegate = nullptr;
736 delete manager;
737 manager = nullptr;
738
739 /**
740 * @tc.steps: step2. reopen db.
741 * @tc.expected: step2. reopen db successful.
742 */
743 option05.createIfNecessary = IS_NOT_NEED_CREATE;
744 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option05);
745 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
746
747 /**
748 * @tc.steps: step3. get the system info before close db.
749 * @tc.expected: step3. reopen db successful.
750 */
751 MST_LOG("System info before close db again and again");
752 DistributedTestSysInfo sysInfo05;
753 sysInfo05.GetSysMemOccpy(FIRST);
754 sysInfo05.GetSysCpuUsage(FIRST, DEFAULT_INTEVAL);
755 sysInfo05.GetSysCurrentPower(FIRST, DEFAULT_COUNT, DEFAULT_INTEVAL);
756 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
757 delegate = nullptr;
758 delete manager;
759 manager = nullptr;
760
761 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option05);
762 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
763
764 /**
765 * @tc.steps: step4. get the system info after reopening db.
766 * @tc.expected: step4. the system has no memory leak.
767 */
768 MST_LOG("System info after opening db again and again");
769 sysInfo05.GetSysMemOccpy(SECOND);
770 sysInfo05.GetSysCpuUsage(SECOND, DEFAULT_INTEVAL);
771 sysInfo05.GetSysCurrentPower(SECOND, DEFAULT_COUNT, DEFAULT_INTEVAL);
772
773 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
774 delegate = nullptr;
775 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
776 delete manager;
777 manager = nullptr;
778 }
779
780 /*
781 * @tc.name: Performance 006
782 * @tc.desc: check the handler using when reopening by reopening db.
783 * @tc.type: System overhead
784 * @tc.require: SR000BUH3J
785 * @tc.author: luqianfu
786 */
787 HWTEST_F(DistributeddbKvCreateTest, Performance006, TestSize.Level2)
788 {
789 KvStoreDelegate *delegate = nullptr;
790 KvStoreDelegateManager *manager = nullptr;
791 /**
792 * @tc.steps: step1. create and close kv db.
793 * @tc.expected: step1. Construct that database exist.
794 */
795 KvOption option06 = g_kvOption;
796 option06.localOnly = IS_LOCAL_ONLY;
797 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
798 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
799 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
800 delegate = nullptr;
801 delete manager;
802 manager = nullptr;
803 /**
804 * @tc.steps: step2. reopen by reopen db three times.
805 * @tc.expected: step2. reopen db successful and the system has no handle overflow.
806 */
807 option06.createIfNecessary = IS_NOT_NEED_CREATE;
808 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
809 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
810 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
811 delegate = nullptr;
812 delete manager;
813 manager = nullptr;
814
815 option06.createIfNecessary = IS_NEED_CREATE;
816 option06.localOnly = IS_NOT_LOCAL_ONLY;
817 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
818 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
819 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
820 delegate = nullptr;
821 delete manager;
822 manager = nullptr;
823
824 delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
825 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
826 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
827 delegate = nullptr;
828
829 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
830 delete manager;
831 manager = nullptr;
832 }
833
834 /*
835 * @tc.name: PathException 001
836 * @tc.desc: check it that can't create kv db without setting path with manager->SetKvStoreConfig(KV_CONFIG) interface.
837 * @tc.type: EXCEPTION
838 * @tc.require: SR000BUH3J
839 * @tc.author: luqianfu
840 */
841 HWTEST_F(DistributeddbKvCreateTest, PathException001, TestSize.Level2)
842 {
843 KvStoreDelegateManager *manager = nullptr;
844 KvStoreDelegate *delegate = nullptr;
845
846 SetDir(DIRECTOR);
847 DelegateKvMgrCallback delegateKvMgrCallback;
848 function<void(DBStatus, KvStoreDelegate*)> function
849 = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
850
851 manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
852 ASSERT_NE(manager, nullptr);
853 /**
854 * @tc.steps: step1. create kv db without setting path with manager->SetKvStoreConfig(KV_CONFIG) interface.
855 * @tc.expected: step1. create and close db failed.
856 */
857 KvStoreDelegate::Option option = DistributedTestTools::TransferKvOptionType(g_kvOption);
858 manager->GetKvStore(STORE_ID_1, option, function);
859 EXPECT_EQ(delegateKvMgrCallback.GetStatus(), DBStatus::INVALID_ARGS);
860
861 delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
862 EXPECT_EQ(delegate, nullptr);
863 EXPECT_EQ(manager->CloseKvStore(delegate), INVALID_ARGS);
864 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::INVALID_ARGS);
865
866 delete manager;
867 manager = nullptr;
868 }
869
870 /*
871 * @tc.name: PathException 002
872 * @tc.desc: create kv db after setting no existing path.
873 * @tc.type: EXCEPTION
874 * @tc.require: SR000BUH3J
875 * @tc.author: luqianfu
876 */
877 HWTEST_F(DistributeddbKvCreateTest, PathException002, TestSize.Level2)
878 {
879 /**
880 * @tc.steps: step1. create kv db when setting no existing path.
881 * @tc.expected: step1. create db failed.
882 */
883 DelegateKvMgrCallback delegateKvMgrCallback;
884 function<void(DBStatus, KvStoreDelegate*)> function
885 = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
886
887 KvStoreConfig config;
888 config.dataDir = "/NOTFOUUD/PATH";
889
890 KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
891 ASSERT_NE(manager, nullptr);
892 KvStoreDelegate::Option option = {true, true};
893
894 EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::INVALID_ARGS);
895
896 manager->GetKvStore(STORE_ID_1, option, function);
897 EXPECT_EQ(delegateKvMgrCallback.GetStatus(), INVALID_ARGS);
898
899 KvStoreDelegate* delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
900 EXPECT_EQ(delegate, nullptr);
901 EXPECT_EQ(manager->CloseKvStore(delegate), INVALID_ARGS);
902 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::INVALID_ARGS);
903 delete manager;
904 manager = nullptr;
905 }
906
907 /*
908 * @tc.name: PathException 003
909 * @tc.desc: create kv db with invalid-char param.
910 * @tc.type: EXCEPTION
911 * @tc.require: SR000BUH3J
912 * @tc.author: luqianfu
913 */
914 HWTEST_F(DistributeddbKvCreateTest, PathException003, TestSize.Level2)
915 {
916 char chinese[5] = { static_cast<char>(0xD6), static_cast<char>(0xD0),
917 static_cast<char>(0xCE), static_cast<char>(0xC4) }; // not good ascii letters:<D6><D0><CE><C4>
918 std::string chStr = chinese;
919 MST_LOG("%s", chStr.c_str());
920
921 DelegateKvMgrCallback exceptionCallback;
922 function<void(DBStatus, KvStoreDelegate*)> function
923 = bind(&DelegateKvMgrCallback::Callback, &exceptionCallback, std::placeholders::_1, std::placeholders::_2);
924 KvStoreConfig config;
925 config.dataDir = "";
926 /**
927 * @tc.steps: step1. create kv db with the path is null.
928 * @tc.expected: step1. create db failed.
929 */
930 KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
931 ASSERT_NE(manager, nullptr);
932 KvStoreDelegate::Option option = {true, true};
933 EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::INVALID_ARGS);
934 manager->GetKvStore(STORE_ID_1, option, function);
935 EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
936 delete manager;
937 manager = nullptr;
938 /**
939 * @tc.steps: step1. create kv db with storeId="中文".
940 * @tc.expected: step1. create db failed.
941 */
942 SetDir(DIRECTOR);
943 config.dataDir = DIRECTOR;
944 manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
945 ASSERT_NE(manager, nullptr);
946 EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
947 manager->GetKvStore(chStr, option, function);
948 EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
949 delete manager;
950 manager = nullptr;
951
952 /**
953 * @tc.steps: step2. create kv db with appId="中文".
954 * @tc.expected: step2. create db failed.
955 */
956 manager = new (std::nothrow) KvStoreDelegateManager(chStr, USER_ID_1);
957 ASSERT_NE(manager, nullptr);
958 EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
959 manager->GetKvStore(chStr, option, function);
960 EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
961 delete manager;
962 manager = nullptr;
963 /**
964 * @tc.steps: step3. create kv db with userId="中文".
965 * @tc.expected: step3. create db failed.
966 */
967 manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, chStr);
968 ASSERT_NE(manager, nullptr);
969 EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
970 manager->GetKvStore(chStr, option, function);
971 EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
972 delete manager;
973 manager = nullptr;
974 }
975
976 /*
977 * @tc.name: PathException 004
978 * @tc.desc: create kv db with too long param.
979 * @tc.type: EXCEPTION
980 * @tc.require: SR000BUH3J
981 * @tc.author: luqianfu
982 */
983 HWTEST_F(DistributeddbKvCreateTest, PathException004, TestSize.Level2)
984 {
985 std::string storeTooLongID, appTooLongID, userTooLongID;
986 storeTooLongID.append(TWO_M_LONG_STRING, 'a');
987 appTooLongID.append(TWO_M_LONG_STRING, 'b');
988 userTooLongID.append(TWO_M_LONG_STRING, 'c');
989
990 KvStoreDelegateManager *manager1 = nullptr;
991 KvStoreDelegateManager *manager2 = nullptr;
992 KvStoreDelegateManager *manager3 = nullptr;
993 KvStoreDelegate *delegate1 = nullptr;
994 KvStoreDelegate *delegate2 = nullptr;
995 KvStoreDelegate *delegate3 = nullptr;
996 /**
997 * @tc.steps: step1. create kv db with storeId=storeTooLongID.
998 * @tc.expected: step1. create db failed.
999 */
1000 DBStatus status1 = DistributedTestTools::GetDelegateNotGood(manager1, delegate1,
1001 storeTooLongID, APP_ID_1, USER_ID_1, g_kvOption);
1002 EXPECT_EQ(delegate1, nullptr);
1003 EXPECT_EQ(manager1->CloseKvStore(delegate1), INVALID_ARGS);
1004 /**
1005 * @tc.steps: step2. create kv db with appId=appTooLongID.
1006 * @tc.expected: step2. create db failed.
1007 */
1008 DBStatus status2 = DistributedTestTools::GetDelegateNotGood(manager2, delegate2,
1009 USER_ID_1, appTooLongID, USER_ID_1, g_kvOption);
1010 EXPECT_EQ(delegate2, nullptr);
1011 EXPECT_EQ(manager2->CloseKvStore(delegate2), INVALID_ARGS);
1012 /**
1013 * @tc.steps: step3. create kv db with userId=userTooLongID.
1014 * @tc.expected: step3. create db failed.
1015 */
1016 DBStatus status3 = DistributedTestTools::GetDelegateNotGood(manager3, delegate3,
1017 USER_ID_1, APP_ID_1, userTooLongID, g_kvOption);
1018 EXPECT_EQ(delegate3, nullptr);
1019 EXPECT_EQ(manager3->CloseKvStore(delegate3), INVALID_ARGS);
1020
1021 ASSERT_EQ(status1, DBStatus::INVALID_ARGS);
1022 ASSERT_EQ(status2, DBStatus::INVALID_ARGS);
1023 ASSERT_EQ(status3, DBStatus::INVALID_ARGS);
1024
1025 delete manager1;
1026 manager1 = nullptr;
1027 delete manager2;
1028 manager2 = nullptr;
1029 delete manager3;
1030 manager3 = nullptr;
1031 }
1032
1033 /*
1034 * @tc.name: PathException 005
1035 * @tc.desc: verify that the same DB can be reopen many times.
1036 * @tc.type: Stability
1037 * @tc.require: SR000BUH3J
1038 * @tc.author: luqianfu
1039 */
1040 HWTEST_F(DistributeddbKvCreateTest, PathException005, TestSize.Level2)
1041 {
1042 KvStoreDelegate *result = nullptr;
1043 KvStoreDelegateManager *manager = nullptr;
1044 /**
1045 * @tc.steps: step1. create and close kv db.
1046 * @tc.expected: step1. Construct that database exist.
1047 */
1048 KvOption option = g_kvOption;
1049 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1_1_2, option);
1050 ASSERT_TRUE(manager != nullptr && result != nullptr);
1051 EXPECT_EQ(manager->CloseKvStore(result), OK);
1052 result = nullptr;
1053
1054 /**
1055 * @tc.steps: step2. reopen kv db five times.
1056 * @tc.expected: step2. reopen successfully and no memory exception when closing db.
1057 */
1058 option.createIfNecessary = IS_NEED_CREATE;
1059 KvStoreDelegate::Option optionUsedForGetStore = DistributedTestTools::TransferKvOptionType(option);
1060
1061 DelegateKvMgrCallback delegateCallback;
1062 function<void(DBStatus, KvStoreDelegate*)> function
1063 = bind(&DelegateKvMgrCallback::Callback, &delegateCallback, std::placeholders::_1, std::placeholders::_2);
1064 KvStoreDelegate* delegate = nullptr;
1065 for (int operCnt = 1; operCnt <= OPER_CNT; ++operCnt) {
1066 manager->GetKvStore(STORE_ID_1, optionUsedForGetStore, function);
1067 EXPECT_EQ(delegateCallback.GetStatus(), OK);
1068 delegate = const_cast<KvStoreDelegate*>(delegateCallback.GetKvStore());
1069 EXPECT_NE(delegate, nullptr);
1070
1071 EXPECT_EQ(manager->CloseKvStore(delegate), OK);
1072 delegate = nullptr;
1073 }
1074
1075 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::OK);
1076 delete manager;
1077 manager = nullptr;
1078 }
1079
1080 /*
1081 * @tc.name: PathException 006
1082 * @tc.desc: verify that one delegate can be closed only one time.
1083 * @tc.type: EXCEPTION
1084 * @tc.require: SR000BUH3J
1085 * @tc.author: luqianfu
1086 */
1087 HWTEST_F(DistributeddbKvCreateTest, PathException006, TestSize.Level2)
1088 {
1089 KvStoreDelegate *result = nullptr;
1090 KvStoreDelegateManager *manager = nullptr;
1091 /**
1092 * @tc.steps: step1. create and close kv db.
1093 * @tc.expected: step1. Construct that database exist.
1094 */
1095 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1_1_2, g_kvOption);
1096 ASSERT_TRUE(manager != nullptr && result != nullptr);
1097 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1098 result = nullptr;
1099
1100 /**
1101 * @tc.steps: step2. create and close kv db more four times.
1102 * @tc.expected: step2. close successfully and no memory leak.
1103 */
1104 for (int operCnt = 1; operCnt <= OPER_CNT; ++operCnt) {
1105 EXPECT_EQ(manager->CloseKvStore(result), INVALID_ARGS);
1106 }
1107
1108 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1109 delete manager;
1110 manager = nullptr;
1111 }
1112
1113 /*
1114 * @tc.name: PathException 007
1115 * @tc.desc: open deleted kv db.
1116 * @tc.type: EXCEPTION
1117 * @tc.require: SR000BUH3J
1118 * @tc.author: luqianfu
1119 */
1120 HWTEST_F(DistributeddbKvCreateTest, PathException007, TestSize.Level2)
1121 {
1122 KvStoreDelegateManager *manager1 = nullptr;
1123 KvStoreDelegateManager *manager2 = nullptr;
1124 KvStoreDelegate *delegate1 = nullptr;
1125 KvStoreDelegate *delegate2 = nullptr;
1126 /**
1127 * @tc.steps: step1. create and close kv db.
1128 * @tc.expected: step1. Construct that database exist.
1129 */
1130 delegate1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1_1_2, g_kvOption);
1131 ASSERT_TRUE(manager1 != nullptr && delegate1 != nullptr);
1132 EXPECT_TRUE(manager1->CloseKvStore(delegate1) == OK);
1133 delegate1 = nullptr;
1134
1135 /**
1136 * @tc.steps: step2. delete the DB.
1137 * @tc.expected: step2. delete successfully.
1138 */
1139 EXPECT_EQ(manager1->DeleteKvStore(STORE_ID_1), OK);
1140 delete manager1;
1141 manager1 = nullptr;
1142 /**
1143 * @tc.steps: step3. open the deleted DB with the mode createIfNecessary = IS_NOT_NEED_CREATE.
1144 * @tc.expected: step3. open failed and return error.
1145 */
1146 KvOption option = g_kvOption;
1147 option.createIfNecessary = IS_NOT_NEED_CREATE;
1148 option.localOnly = IS_LOCAL_ONLY;
1149 DBStatus status = DistributedTestTools::GetDelegateNotGood(manager2, delegate2,
1150 STORE_ID_1, APP_ID_1, USER_ID_2, option);
1151 EXPECT_TRUE(delegate2 == nullptr);
1152 EXPECT_EQ(manager2->CloseKvStore(delegate2), INVALID_ARGS);
1153 ASSERT_NE(status, OK);
1154
1155 delete manager2;
1156 manager2 = nullptr;
1157 }
1158
1159 /*
1160 * @tc.name: ConflictConfig 001
1161 * @tc.desc: check SetConflictResolutionPolicy interface with AUTO_LAST_WIN mode
1162 * @tc.type: LONGTIME TEST
1163 * @tc.require: SR000CCPOI
1164 * @tc.author: luqianfu
1165 */
1166 HWTEST_F(DistributeddbKvCreateTest, ConflictConfig001, TestSize.Level1)
1167 {
1168 KvStoreDelegate *conflictDelegate = nullptr;
1169 KvStoreDelegateManager *manager = nullptr;
1170 conflictDelegate = DistributedTestTools::GetDelegateSuccess(manager,
1171 g_kvdbParameter1_1_2, g_kvOption);
1172 ASSERT_TRUE(manager != nullptr && conflictDelegate != nullptr);
1173
1174 /**
1175 * @tc.steps: step1. check SetConflictResolutionPolicy interface with AUTO_LAST_WIN mode.
1176 * @tc.expected: step1. return ok.
1177 */
1178 EXPECT_EQ(conflictDelegate->SetConflictResolutionPolicy(AUTO_LAST_WIN, nullptr), OK);
1179
1180 EXPECT_TRUE(manager->CloseKvStore(conflictDelegate) == OK);
1181 conflictDelegate = nullptr;
1182 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1183 delete manager;
1184 manager = nullptr;
1185 }
1186
1187 /*
1188 * @tc.name: ConflictConfig 002
1189 * @tc.desc: check SetConflictResolutionPolicy interface with CUSTOMER_RESOLUTION mode
1190 * @tc.type: LONGTIME TEST
1191 * @tc.require: SR000CCPOI
1192 * @tc.author: luqianfu
1193 */
1194 HWTEST_F(DistributeddbKvCreateTest, ConflictConfig002, TestSize.Level1)
1195 {
1196 KvStoreDelegate *conflictDelegate = nullptr;
1197 KvStoreDelegateManager *manager = nullptr;
1198 conflictDelegate = DistributedTestTools::GetDelegateSuccess(manager,
1199 g_kvdbParameter1_1_2, g_kvOption);
1200 ASSERT_TRUE(manager != nullptr && conflictDelegate != nullptr);
1201
1202 /**
1203 * @tc.steps: step1. check SetConflictResolutionPolicy interface with CUSTOMER_RESOLUTION mode.
1204 * @tc.expected: step1. return error.
1205 */
1206 EXPECT_NE(conflictDelegate->SetConflictResolutionPolicy(CUSTOMER_RESOLUTION, nullptr), OK);
1207
1208 EXPECT_TRUE(manager->CloseKvStore(conflictDelegate) == OK);
1209 conflictDelegate = nullptr;
1210 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1211 delete manager;
1212 manager = nullptr;
1213 }
1214
1215 /*
1216 * @tc.name: ConflictConfig 003
1217 * @tc.desc: check SetConflictResolutionPolicy interface with invalid mode
1218 * @tc.type: LONGTIME TEST
1219 * @tc.require: SR000CCPOI
1220 * @tc.author: luqianfu
1221 */
1222 HWTEST_F(DistributeddbKvCreateTest, ConflictConfig003, TestSize.Level1)
1223 {
1224 KvStoreDelegate *conflictDelegate = nullptr;
1225 KvStoreDelegateManager *manager = nullptr;
1226 conflictDelegate = DistributedTestTools::GetDelegateSuccess(manager,
1227 g_kvdbParameter1_1_2, g_kvOption);
1228 ASSERT_TRUE(manager != nullptr && conflictDelegate != nullptr);
1229
1230 /**
1231 * @tc.steps: step1. check SetConflictResolutionPolicy interface with invalid mode.
1232 * @tc.expected: step1. return ok.
1233 */
1234 EXPECT_EQ(conflictDelegate->SetConflictResolutionPolicy(static_cast<ResolutionPolicyType>(2), nullptr), DB_ERROR);
1235 EXPECT_EQ(conflictDelegate->SetConflictResolutionPolicy(static_cast<ResolutionPolicyType>(-1), nullptr), DB_ERROR);
1236
1237 EXPECT_TRUE(manager->CloseKvStore(conflictDelegate) == OK);
1238 conflictDelegate = nullptr;
1239 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1240 delete manager;
1241 manager = nullptr;
1242 }
1243
1244 /*
1245 * @tc.name: OptionParam 001
1246 * @tc.desc: verify that will check the option parameter when create encrypted DB.
1247 * @tc.type: FUNC
1248 * @tc.require: SR000CQDT4
1249 * @tc.author: fengxiaoyun
1250 */
1251 HWTEST_F(DistributeddbKvCreateTest, OptionParam001, TestSize.Level1)
1252 {
1253 vector<KvStoreDelegateManager *> manager = {nullptr, nullptr, nullptr};
1254 vector<KvStoreDelegate*> result = {nullptr, nullptr, nullptr, nullptr, nullptr};
1255 KvOption option;
1256 vector<uint8_t> password;
1257
1258 /**
1259 * @tc.steps: step1. isEncryptedDb=true, passwd=NULL, cipher=DEFAULT when create db.
1260 * @tc.expected: step1. create failed and return INVALID_ARGS.
1261 */
1262 option.isEncryptedDb = true;
1263 option.cipher = CipherType::DEFAULT;
1264 option.passwd = NULL_PASSWD_VECTOR;
1265 DBStatus status;
1266 result[INDEX_ZEROTH] = DistributedTestTools::GetDelegateStatus(manager[INDEX_ZEROTH],
1267 status, g_kvdbParameter1, option);
1268 EXPECT_TRUE(manager[INDEX_ZEROTH] == nullptr && result[INDEX_ZEROTH] == nullptr);
1269 EXPECT_TRUE(status == INVALID_ARGS);
1270
1271 /**
1272 * @tc.steps: step2. isEncryptedDb=true, passwd=a......(100B) when create db.
1273 * @tc.expected: step2. create successfully and return OK.
1274 */
1275 password.assign(VALUE_ONE_HUNDRED_BYTE, 'a');
1276 option.passwd = password;
1277 result[INDEX_FIRST] = DistributedTestTools::GetDelegateSuccess(manager[INDEX_ZEROTH], g_kvdbParameter1, option);
1278 ASSERT_TRUE(manager[INDEX_ZEROTH] != nullptr && result[INDEX_FIRST] != nullptr);
1279 EXPECT_EQ(manager[INDEX_ZEROTH]->CloseKvStore(result[INDEX_FIRST]), OK);
1280 result[INDEX_FIRST] = nullptr;
1281
1282 /**
1283 * @tc.steps: step3. isEncryptedDb=true, passwd=a......(128B), cipher=AES_256_GCM when create db.
1284 * @tc.expected: step3. create successfully and return OK.
1285 */
1286 password.clear();
1287 password.assign(BATCH_RECORDS, 'a');
1288 option.cipher = CipherType::AES_256_GCM;
1289 option.passwd = password;
1290 result[INDEX_SECOND] = DistributedTestTools::GetDelegateSuccess(manager[INDEX_FIRST], g_kvdbParameter2, option);
1291 ASSERT_TRUE(manager[INDEX_FIRST] != nullptr && result[INDEX_SECOND] != nullptr);
1292 EXPECT_EQ(manager[INDEX_FIRST]->CloseKvStore(result[INDEX_SECOND]), OK);
1293 result[INDEX_SECOND] = nullptr;
1294
1295 /**
1296 * @tc.steps: step4. isEncryptedDb=true, passwd=a......(129B), cipher=DEFAULT when create db.
1297 * @tc.expected: step4. create failed and return INVALID_ARGS.
1298 */
1299 password.clear();
1300 password.assign(PASSWD_BYTE, 'a');
1301 option.cipher = CipherType::DEFAULT;
1302 option.passwd = password;
1303 result[INDEX_THIRD] = DistributedTestTools::GetDelegateStatus(manager[INDEX_SECOND],
1304 status, g_kvdbParameter3, option);
1305 EXPECT_TRUE(manager[INDEX_SECOND] == nullptr && result[INDEX_THIRD] == nullptr);
1306 EXPECT_TRUE(status == INVALID_ARGS);
1307
1308 /**
1309 * @tc.steps: step5. isEncryptedDb=false, passwd=a......(129B), cipher=DEFAULT when create db.
1310 * @tc.expected: step5. create successfully and return OK.
1311 */
1312 option.isEncryptedDb = false;
1313 result[INDEX_FORTH] = DistributedTestTools::GetDelegateSuccess(manager[INDEX_SECOND], g_kvdbParameter3, option);
1314 ASSERT_TRUE(manager[INDEX_SECOND] != nullptr && result[INDEX_FORTH] != nullptr);
1315 EXPECT_EQ(manager[INDEX_SECOND]->CloseKvStore(result[INDEX_FORTH]), OK);
1316 result[INDEX_FORTH] = nullptr;
1317
1318 EXPECT_EQ(manager[INDEX_ZEROTH]->DeleteKvStore(STORE_ID_1), OK);
1319 EXPECT_EQ(manager[INDEX_FIRST]->DeleteKvStore(STORE_ID_2), OK);
1320 EXPECT_EQ(manager[INDEX_SECOND]->DeleteKvStore(STORE_ID_3), OK);
1321 for (auto &item : manager) {
1322 if (item != nullptr) {
1323 delete item;
1324 }
1325 }
1326 }
1327
1328 /*
1329 * @tc.name: OptionParam 002
1330 * @tc.desc: verify that isEncryptedDb and passwd are consistent with the creation time can open an existing DB.
1331 * @tc.type: FUNC
1332 * @tc.require: SR000CQDT4
1333 * @tc.author: fengxiaoyun
1334 */
1335 HWTEST_F(DistributeddbKvCreateTest, OptionParam002, TestSize.Level1)
1336 {
1337 vector<KvStoreDelegateManager *> manager = {nullptr, nullptr, nullptr, nullptr};
1338 KvStoreDelegate *result = nullptr;
1339 KvOption option;
1340
1341 /**
1342 * @tc.steps: step1. isEncryptedDb=true, passwd=p1, cipher=DEFAULT when create db1.
1343 * @tc.expected: step1. create successfully and return OK.
1344 */
1345 option.isEncryptedDb = true;
1346 option.passwd = PASSWD_VECTOR_1;
1347 result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_ZEROTH], g_kvdbParameter1, option);
1348 ASSERT_TRUE(manager[INDEX_ZEROTH] != nullptr && result != nullptr);
1349 EXPECT_TRUE(manager[INDEX_ZEROTH]->CloseKvStore(result) == OK);
1350 result = nullptr;
1351 /**
1352 * @tc.steps: step2. isEncryptedDb=false, passwd=p1 when open db1.
1353 * @tc.expected: step2. open failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1354 */
1355 option.isEncryptedDb = false;
1356 DBStatus status;
1357 result = DistributedTestTools::GetDelegateStatus(manager[INDEX_FIRST], status, g_kvdbParameter1, option);
1358 EXPECT_TRUE(manager[INDEX_FIRST] == nullptr && result == nullptr);
1359 EXPECT_TRUE(status == INVALID_PASSWD_OR_CORRUPTED_DB);
1360
1361 /**
1362 * @tc.steps: step3. isEncryptedDb=true, passwd=p2 when open db1.
1363 * @tc.expected: step3. open failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1364 */
1365 option.isEncryptedDb = true;
1366 option.passwd = PASSWD_VECTOR_2;
1367 result = DistributedTestTools::GetDelegateStatus(manager[INDEX_FIRST], status, g_kvdbParameter1, option);
1368 EXPECT_TRUE(manager[INDEX_FIRST] == nullptr && result == nullptr);
1369 EXPECT_TRUE(status == INVALID_PASSWD_OR_CORRUPTED_DB);
1370
1371 /**
1372 * @tc.steps: step4. isEncryptedDb=true, passwd=p1 when open db1.
1373 * @tc.expected: step4. open successfully and return OK.
1374 */
1375 option.passwd = PASSWD_VECTOR_1;
1376 result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_FIRST], g_kvdbParameter1, option);
1377 ASSERT_TRUE(manager[INDEX_FIRST] != nullptr && result != nullptr);
1378 EXPECT_TRUE(manager[INDEX_FIRST]->CloseKvStore(result) == OK);
1379 result = nullptr;
1380
1381 /**
1382 * @tc.steps: step5. isEncryptedDb=false, passwd=p1, cipher=DEFAULT when create db2.
1383 * @tc.expected: step5. create successfully and return OK.
1384 */
1385 option.isEncryptedDb = false;
1386 result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_SECOND], g_kvdbParameter2, option);
1387 ASSERT_TRUE(manager[INDEX_SECOND] != nullptr && result != nullptr);
1388 EXPECT_TRUE(manager[INDEX_SECOND]->CloseKvStore(result) == OK);
1389 result = nullptr;
1390
1391 /**
1392 * @tc.steps: step6. isEncryptedDb=true, passwd=p1 when open db2.
1393 * @tc.expected: step6. open failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1394 */
1395 option.isEncryptedDb = true;
1396 result = DistributedTestTools::GetDelegateStatus(manager[INDEX_THIRD], status, g_kvdbParameter2, option);
1397 EXPECT_TRUE(manager[INDEX_THIRD] == nullptr && result == nullptr);
1398 EXPECT_TRUE(status == INVALID_PASSWD_OR_CORRUPTED_DB);
1399
1400 /**
1401 * @tc.steps: step7. isEncryptedDb=false, passwd=p2 when open db2.
1402 * @tc.expected: step7. open successfully and return OK.
1403 */
1404 option.isEncryptedDb = false;
1405 option.passwd = PASSWD_VECTOR_2;
1406 result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_THIRD], g_kvdbParameter2, option);
1407 ASSERT_TRUE(manager[INDEX_THIRD] != nullptr && result != nullptr);
1408 EXPECT_TRUE(manager[INDEX_THIRD]->CloseKvStore(result) == OK);
1409 result = nullptr;
1410 EXPECT_TRUE(manager[INDEX_FIRST]->DeleteKvStore(STORE_ID_1) == OK);
1411 EXPECT_TRUE(manager[INDEX_THIRD]->DeleteKvStore(STORE_ID_2) == OK);
1412 for (auto &item : manager) {
1413 if (item != nullptr) {
1414 delete item;
1415 item = nullptr;
1416 }
1417 }
1418 }
1419
ReleaseManager(KvStoreDelegateManager * & manager)1420 void ReleaseManager(KvStoreDelegateManager *&manager)
1421 {
1422 if (manager != nullptr) {
1423 delete manager;
1424 manager = nullptr;
1425 }
1426 return;
1427 }
1428 /*
1429 * @tc.name: RekeyDb 001
1430 * @tc.desc: verify that can switching a non-encrypted database to an encrypted database by Rekey.
1431 * @tc.type: FUNC
1432 * @tc.require: SR000CQDT4
1433 * @tc.author: fengxiaoyun
1434 */
1435 HWTEST_F(DistributeddbKvCreateTest, RekeyDb001, TestSize.Level1)
1436 {
1437 KvStoreDelegateManager *manager = nullptr;
1438 KvStoreDelegate *result = nullptr;
1439 KvOption option;
1440
1441 /**
1442 * @tc.steps: step1. create unencrypted db, use Rekey to update its passwd to NULL,
1443 * then close and open without passwd.
1444 * @tc.expected: step1. operate successfully and can open db again without passwd.
1445 */
1446 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1447 ASSERT_TRUE(manager != nullptr && result != nullptr);
1448 EXPECT_TRUE(result->Rekey(NULL_PASSWD) == OK);
1449 DistributedTestTools::CloseAndRelease(manager, result);
1450 option.createIfNecessary = false;
1451 option.isEncryptedDb = false;
1452 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1453 ASSERT_TRUE(manager != nullptr && result != nullptr);
1454 ASSERT_TRUE(DistributedTestTools::Put(*result, KEY_1, VALUE_1) == DBStatus::OK);
1455
1456 /**
1457 * @tc.steps: step2. use Rekey to update db's passwd to p1=a......(100B), then close
1458 * and open again without passwd.
1459 * @tc.expected: step2. Rekey is ok, open db failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1460 */
1461 vector<uint8_t> passwordVector(VALUE_ONE_HUNDRED_BYTE, 'a');
1462 CipherPassword password;
1463 EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OK);
1464 EXPECT_TRUE(result->Rekey(password) == OK);
1465 DistributedTestTools::CloseAndRelease(manager, result);
1466 DBStatus status;
1467 ASSERT_TRUE(DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option) == nullptr);
1468 EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1469
1470 /**
1471 * @tc.steps: step3. use p1 to open db and Get(k1), GetLocal(k1).
1472 * @tc.expected: step3. open successfully and Get(k1)=v1.
1473 */
1474 option.isEncryptedDb = true;
1475 option.passwd = passwordVector;
1476 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1477 ASSERT_TRUE(manager != nullptr && result != nullptr);
1478 Value valueResult = DistributedTestTools::Get(*result, KEY_1);
1479 EXPECT_TRUE(valueResult.size() != 0);
1480 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
1481
1482 /**
1483 * @tc.steps: step4. use Rekey to update db's passwd to p2=passwordVector whose size is 128B, then close
1484 * and open again with p1.
1485 * @tc.expected: step4. Rekey is ok, open db failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1486 */
1487 passwordVector.assign(BATCH_RECORDS, 'a');
1488 EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OK);
1489 EXPECT_TRUE(result->Rekey(password) == OK);
1490 DistributedTestTools::CloseAndRelease(manager, result);
1491 ASSERT_TRUE(DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option) == nullptr);
1492 EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1493
1494 /**
1495 * @tc.steps: step5. use p2 to open db and delete(k1).
1496 * @tc.expected: step5. operate successfully.
1497 */
1498 option.passwd = passwordVector;
1499 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1500 ASSERT_TRUE(manager != nullptr && result != nullptr);
1501 ASSERT_TRUE(DistributedTestTools::Delete(*result, KEY_1) == OK);
1502
1503 /**
1504 * @tc.steps: step6. use Rekey to update db's passwd to p2=passwordVector whose size is 129B.
1505 * @tc.expected: step6. Rekey failed and return INVALID_ARGS.
1506 */
1507 passwordVector.assign(PASSWD_BYTE, 'a');
1508 EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OVERSIZE);
1509
1510 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1511 result = nullptr;
1512 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1513 ReleaseManager(manager);
1514 }
1515
1516 /*
1517 * @tc.name: RekeyDb 002
1518 * @tc.desc: verify that can change passwd of an encrypted database by Rekey.
1519 * @tc.type: FUNC
1520 * @tc.require: SR000CQDT4
1521 * @tc.author: fengxiaoyun
1522 */
1523 HWTEST_F(DistributeddbKvCreateTest, RekeyDb002, TestSize.Level1)
1524 {
1525 KvStoreDelegateManager *manager = nullptr;
1526 KvStoreDelegate *result = nullptr;
1527 KvOption option;
1528
1529 /**
1530 * @tc.steps: step1. create encrypted db with p1=PASSWD_VECTOR_1.
1531 * @tc.expected: step1. create successfully.
1532 */
1533 option.isEncryptedDb = true;
1534 option.passwd = PASSWD_VECTOR_1;
1535 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1536 ASSERT_TRUE(manager != nullptr && result != nullptr);
1537
1538 /**
1539 * @tc.steps: step2. use Rekey to update passwd to p1 and close db then open db again with unencrypted way.
1540 * @tc.expected: step2. the Rekey return OK, but open db failed.
1541 */
1542 EXPECT_TRUE(result->Rekey(g_passwd1) == OK);
1543 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1544 result = nullptr;
1545 ReleaseManager(manager);
1546 option.createIfNecessary = false;
1547 option.isEncryptedDb = false;
1548 DBStatus status;
1549 result = DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option);
1550 ASSERT_TRUE(result == nullptr);
1551 EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1552
1553 /**
1554 * @tc.steps: step3. open db with passwd=p1 and putbatch(k1,v1)(k2,v2).
1555 * @tc.expected: step3. operate successfully.
1556 */
1557 option.isEncryptedDb = true;
1558 option.passwd = PASSWD_VECTOR_1;
1559 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1560 ASSERT_TRUE(manager != nullptr && result != nullptr);
1561 vector<Entry> entries1;
1562 entries1.push_back(ENTRY_1);
1563 entries1.push_back(ENTRY_2);
1564 EXPECT_TRUE(DistributedTestTools::PutBatch(*result, entries1) == OK);
1565
1566 /**
1567 * @tc.steps: step4. use Rekey to update passwd to NULL and close db then open db with passwd=p1.
1568 * @tc.expected: step4. the Rekey return OK, but open db failed.
1569 */
1570 EXPECT_TRUE(result->Rekey(NULL_PASSWD) == OK);
1571 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1572 result = nullptr;
1573 ReleaseManager(manager);
1574 result = DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option);
1575 ASSERT_TRUE(result == nullptr);
1576 EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1577
1578 /**
1579 * @tc.steps: step5. open db again with unencrypted way and Get(k1), GetLocal(k2).
1580 * @tc.expected: step5. open successfully and Get(k1)=v1, GetLocal(k2)=v2.
1581 */
1582 option.isEncryptedDb = false;
1583 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1584 ASSERT_TRUE(manager != nullptr && result != nullptr);
1585 vector<Entry> valueResult = DistributedTestTools::GetEntries(*result, KEY_EMPTY);
1586 ASSERT_TRUE(valueResult.size() == entries1.size());
1587
1588 /**
1589 * @tc.steps: step6. use Rekey to update db's passwd to p2=a......(129B).
1590 * @tc.expected: step6. Reksy failed and return INVALID_ARGS.
1591 */
1592 vector<uint8_t> passwordVector(PASSWD_BYTE, 'a');
1593 CipherPassword password;
1594 EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OVERSIZE);
1595
1596 EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1597 result = nullptr;
1598 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1599 ReleaseManager(manager);
1600 }
1601
1602 #ifndef LOW_LEVEL_MEM_DEV
1603 /*
1604 * @tc.name: RekeyDb 003
1605 * @tc.desc: verify that do other operations during Rekey execution, the operation returns busy.
1606 * @tc.type: FUNC
1607 * @tc.require: SR000CQDT4
1608 * @tc.author: fengxiaoyun
1609 */
1610 HWTEST_F(DistributeddbKvCreateTest, RekeyDb003, TestSize.Level3)
1611 {
1612 KvStoreDelegateManager *manager = nullptr;
1613 KvStoreDelegate *result1 = nullptr;
1614 KvStoreDelegate *result2 = nullptr;
1615 KvOption option;
1616
1617 /**
1618 * @tc.steps: step1. use Rekey to update passwd to p1=PASSWD_VECTOR_1.
1619 * @tc.expected: step1. create successfully.
1620 */
1621 result1 = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1622 ASSERT_TRUE(manager != nullptr && result1 != nullptr);
1623 std::vector<DistributedDB::Entry> entriesBatch;
1624 std::vector<DistributedDB::Key> allKeys;
1625 GenerateFixedRecords(entriesBatch, allKeys, ONE_HUNDRED_RECORDS, ONE_K_LONG_STRING, ONE_M_LONG_STRING);
1626 EXPECT_EQ(DistributedTestTools::PutBatch(*result1, entriesBatch), OK);
1627 bool rekeyFlag1 = false;
__anon138b19870102() 1628 thread subThread1([&result1, &rekeyFlag1]() {
1629 DBStatus status = result1->Rekey(g_passwd1);
1630 EXPECT_TRUE(status == OK || status == BUSY);
1631 rekeyFlag1 = true;
1632 g_conditionKvVar.notify_one();
1633 });
1634 subThread1.detach();
1635
1636 /**
1637 * @tc.steps: step2. Call the GetKvstore interface when Rekey.
1638 * @tc.expected: step2. the GetKvstore return BUSY.
1639 */
1640 option.createIfNecessary = false;
1641 KvStoreDelegateManager *managerRes = nullptr;
1642 DBStatus status;
1643 result2 = DistributedTestTools::GetDelegateStatus(managerRes, status, g_kvdbParameter1, option);
1644 EXPECT_TRUE(status == BUSY || status == OK);
1645 if (result2 != nullptr) {
1646 EXPECT_EQ(managerRes->CloseKvStore(result2), OK);
1647 ReleaseManager(managerRes);
1648 }
1649 std::mutex count;
1650 {
1651 std::unique_lock<std::mutex> lck(count);
__anon138b19870202null1652 g_conditionKvVar.wait(lck, [&]{return rekeyFlag1;});
1653 }
1654
1655 /**
1656 * @tc.steps: step3. put data to db when Rekey.
1657 * @tc.expected: step3. the put return BUSY.
1658 */
1659 bool rekeyFlag2 = false;
__anon138b19870302() 1660 thread subThread2([&result1, &rekeyFlag2]() {
1661 DBStatus rekeyStatus = result1->Rekey(g_passwd2);
1662 EXPECT_TRUE(rekeyStatus == OK || rekeyStatus == BUSY);
1663 rekeyFlag2 = true;
1664 g_conditionKvVar.notify_all();
1665 });
1666 subThread2.detach();
1667 status = DistributedTestTools::Put(*result1, KEY_1, VALUE_1);
1668 EXPECT_TRUE(status == BUSY || status == OK);
1669 std::unique_lock<std::mutex> lck(count);
__anon138b19870402null1670 g_conditionKvVar.wait(lck, [&]{return rekeyFlag2;});
1671 EXPECT_EQ(manager->CloseKvStore(result1), OK);
1672 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1673 ReleaseManager(manager);
1674 }
1675 #endif
1676
1677 /*
1678 * @tc.name: RekeyDb 004
1679 * @tc.desc: verify that Rekey will return busy when there are multiple instances of the same KvStore.
1680 * @tc.type: FUNC
1681 * @tc.require: SR000CQDT4
1682 * @tc.author: fengxiaoyun
1683 */
1684 HWTEST_F(DistributeddbKvCreateTest, RekeyDb004, TestSize.Level1)
1685 {
1686 KvStoreDelegateManager *manager = nullptr;
1687 KvStoreDelegate *result1 = nullptr;
1688 KvStoreDelegate *result2 = nullptr;
1689 KvOption option;
1690
1691 result1 = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1692 ASSERT_TRUE(manager != nullptr && result1 != nullptr);
1693 ReleaseManager(manager);
1694
1695 /**
1696 * @tc.steps: step1. use GetKvstore to open another instances of the same KvStore.
1697 * @tc.expected: step1. open successfully.
1698 */
1699 option.createIfNecessary = false;
1700 result2 = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1701 ASSERT_TRUE(manager != nullptr && result2 != nullptr);
1702
1703 /**
1704 * @tc.steps: step2. call Rekey.
1705 * @tc.expected: step2. Rekey returns BUSY.
1706 */
1707 EXPECT_EQ(result2->Rekey(g_passwd1), BUSY);
1708 EXPECT_EQ(manager->CloseKvStore(result1), OK);
1709 result1 = nullptr;
1710 EXPECT_EQ(manager->CloseKvStore(result2), OK);
1711 result2 = nullptr;
1712 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1713 ReleaseManager(manager);
1714 }
1715
RunDbRekeyOne()1716 void RunDbRekeyOne()
1717 {
1718 KvStoreDelegateManager *manager1 = nullptr;
1719 KvStoreDelegate *result1 = nullptr;
1720 KvOption option;
1721 option.isEncryptedDb = true;
1722 option.passwd = PASSWD_VECTOR_1;
1723 result1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1, option);
1724 ASSERT_TRUE(manager1 != nullptr && result1 != nullptr);
1725 EXPECT_TRUE(result1->Rekey(g_passwd2) == OK);
1726 EXPECT_TRUE(manager1->CloseKvStore(result1) == OK);
1727 result1 = nullptr;
1728 EXPECT_TRUE(manager1->DeleteKvStore(STORE_ID_1) == OK);
1729 delete manager1;
1730 manager1 = nullptr;
1731 }
1732
RunDbRekeyTwo()1733 void RunDbRekeyTwo()
1734 {
1735 KvStoreDelegateManager *manager2 = nullptr;
1736 KvStoreDelegate *result2 = nullptr;
1737 KvOption option;
1738 option.isEncryptedDb = true;
1739 option.passwd = PASSWD_VECTOR_2;
1740 result2 = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter2, option);
1741 ASSERT_TRUE(manager2 != nullptr && result2 != nullptr);
1742 EXPECT_TRUE(result2->Rekey(g_passwd1) == OK);
1743 EXPECT_TRUE(manager2->CloseKvStore(result2) == OK);
1744 result2 = nullptr;
1745 EXPECT_TRUE(manager2->DeleteKvStore(STORE_ID_2) == OK);
1746 delete manager2;
1747 manager2 = nullptr;
1748 }
1749
RunDbRekeyThree()1750 void RunDbRekeyThree()
1751 {
1752 KvStoreDelegateManager *manager3 = nullptr;
1753 KvStoreDelegate *result3 = nullptr;
1754 KvOption option;
1755 option.isEncryptedDb = true;
1756 option.passwd = PASSWD_VECTOR_1;
1757 result3 = DistributedTestTools::GetDelegateSuccess(manager3, g_kvdbParameter3, option);
1758 ASSERT_TRUE(manager3 != nullptr && result3 != nullptr);
1759 EXPECT_TRUE(result3->Rekey(NULL_PASSWD) == OK);
1760 EXPECT_TRUE(manager3->CloseKvStore(result3) == OK);
1761 result3 = nullptr;
1762 EXPECT_TRUE(manager3->DeleteKvStore(STORE_ID_3) == OK);
1763 delete manager3;
1764 manager3 = nullptr;
1765 }
1766
RunDbRekeyFour()1767 void RunDbRekeyFour()
1768 {
1769 KvStoreDelegateManager *manager4 = nullptr;
1770 KvStoreDelegate *result4 = nullptr;
1771 KvOption option;
1772 result4 = DistributedTestTools::GetDelegateSuccess(manager4, g_kvdbParameter4, option);
1773 ASSERT_TRUE(manager4 != nullptr && result4 != nullptr);
1774 EXPECT_TRUE(result4->Rekey(g_passwd1) == OK);
1775 EXPECT_TRUE(manager4->CloseKvStore(result4) == OK);
1776 result4 = nullptr;
1777 EXPECT_TRUE(manager4->DeleteKvStore(STORE_ID_4) == OK);
1778 delete manager4;
1779 manager4 = nullptr;
1780 }
1781
RunDbRekeyFive()1782 void RunDbRekeyFive()
1783 {
1784 KvStoreDelegateManager *manager5 = nullptr;
1785 KvStoreDelegate *result5 = nullptr;
1786 KvOption option;
1787 result5 = DistributedTestTools::GetDelegateSuccess(manager5, g_kvdbParameter5, option);
1788 ASSERT_TRUE(manager5 != nullptr && result5 != nullptr);
1789 vector<Entry> entries1;
1790 vector<Key> allKey1, allKey2;
1791 GenerateRecords(BATCH_RECORDS, DEFAULT_START, allKey1, entries1, K_SEARCH_3);
1792 DBStatus status = DistributedTestTools::PutBatch(*result5, entries1);
1793 ASSERT_TRUE(status == DBStatus::OK);
1794 DBStatus statusDelete = DistributedTestTools::DeleteBatch(*result5, allKey1);
1795 ASSERT_TRUE(statusDelete == DBStatus::OK);
1796 status = DistributedTestTools::Put(*result5, KEY_1, VALUE_1);
1797 ASSERT_TRUE(status == DBStatus::OK);
1798 Value valueResult = DistributedTestTools::Get(*result5, KEY_1);
1799 EXPECT_TRUE(valueResult.size() != 0);
1800 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
1801 EXPECT_TRUE(manager5->CloseKvStore(result5) == OK);
1802 result5 = nullptr;
1803 EXPECT_TRUE(manager5->DeleteKvStore(STORE_ID_5) == OK);
1804 delete manager5;
1805 manager5 = nullptr;
1806 }
1807 /*
1808 * @tc.name: RekeyDb 005
1809 * @tc.desc: verify that calling Rekey interfaces on different DBs does not affect each other..
1810 * @tc.type: FUNC
1811 * @tc.require: SR000CQDT4
1812 * @tc.author: fengxiaoyun
1813 */
1814 HWTEST_F(DistributeddbKvCreateTest, RekeyDb005, TestSize.Level1)
1815 {
1816 /**
1817 * @tc.steps: step1. create thread1 to create db1 with passwd=p1, call Rekey to update passwd to p2=PASSSWD_2.
1818 * @tc.expected: step1. operate successfully.
1819 */
1820 thread subThread1(RunDbRekeyOne);
1821
1822 /**
1823 * @tc.steps: step2. create thread2 to create db2 with passwd=p2, call Rekey to update passwd to p1=PASSSWD_1.
1824 * @tc.expected: step2. operate successfully.
1825 */
1826 thread subThread2(RunDbRekeyTwo);
1827
1828 /**
1829 * @tc.steps: step3. create thread3 to create db3 with passwd=p1, call Rekey to update passwd to NULL_PASSWD.
1830 * @tc.expected: step3. operate successfully.
1831 */
1832 thread subThread3(RunDbRekeyThree);
1833
1834 /**
1835 * @tc.steps: step4. create thread4 to create db4 without passwd, call Rekey to make db to be encrypted.
1836 * @tc.expected: step4. operate successfully.
1837 */
1838 thread subThread4(RunDbRekeyFour);
1839
1840 /**
1841 * @tc.steps: step5. create thread5 to create db5 without passwd, then CRUD data to db5.
1842 * @tc.expected: step5. operate successfully.
1843 */
1844 thread subThread5(RunDbRekeyFive);
1845 subThread1.join();
1846 subThread2.join();
1847 subThread3.join();
1848 subThread5.join();
1849 subThread4.join();
1850 }
1851
1852 /*
1853 * @tc.name: SpaceManger 001
1854 * @tc.desc: verify that can calculate the space size normally with the existing databaseID.
1855 * @tc.type: FUNC
1856 * @tc.require: SR000CQDT4
1857 * @tc.author: fengxiaoyun
1858 */
1859 #ifdef KV_CREATE
1860 HWTEST_F(DistributeddbKvCreateTest, SpaceManger001, TestSize.Level1)
1861 {
1862 KvStoreDelegateManager *manager = nullptr;
1863 KvStoreDelegate *result = nullptr;
1864 KvOption option;
1865 option.isEncryptedDb = true;
1866 option.passwd = PASSWD_VECTOR_1;
1867 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1868 ASSERT_TRUE(manager != nullptr && result != nullptr);
1869 EXPECT_EQ(manager->CloseKvStore(result), OK);
1870 result = nullptr;
1871
1872 /**
1873 * @tc.steps: step1. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1874 * @tc.expected: step1. call successfully and return dbSize1.
1875 */
1876 uint64_t dbSize1, dbSize2, dbSize3;
1877 dbSize1 = dbSize2 = dbSize3 = 0ul;
1878 EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize1), OK);
1879
1880 /**
1881 * @tc.steps: step2. put 100 (keys,values) to db that every item's size = 1K.
1882 * @tc.expected: step2. operate successfully.
1883 */
1884 option.createIfNecessary = false;
1885 ReleaseManager(manager);
1886 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1887 ASSERT_TRUE(manager != nullptr && result != nullptr);
1888 vector<Entry> entriesBatch;
1889 vector<Key> allKeys;
1890 GenerateTenThousandRecords(NB_OPERATION_NUM, DEFAULT_START, allKeys, entriesBatch);
1891 EXPECT_EQ(DistributedTestTools::PutBatch(*result, entriesBatch), OK);
1892
1893 /**
1894 * @tc.steps: step3. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1895 * @tc.expected: step3. call successfully and return dbSize2, dbSize2>dbSize1.
1896 */
1897 EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize2), OK);
1898 EXPECT_GT(dbSize2, dbSize1);
1899
1900 /**
1901 * @tc.steps: step4. delete the 100 (keys,values) that inserted in step2.
1902 * @tc.expected: step4. operate successfully.
1903 */
1904 EXPECT_EQ(DistributedTestTools::DeleteBatch(*result, allKeys), OK);
1905
1906 /**
1907 * @tc.steps: step5. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1908 * @tc.expected: step5. call successfully and return dbSize3, dbSize3>dbSize2 and dbSize3 != dbSize2.
1909 */
1910 EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize3), OK);
1911 EXPECT_GT(dbSize3, dbSize2);
1912 EXPECT_EQ(manager->CloseKvStore(result), OK);
1913 result = nullptr;
1914 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1915 ReleaseManager(manager);
1916 }
1917
1918 /*
1919 * @tc.name: MergeRepeat 001
1920 * @tc.desc: verify that delete 9 items of (keys,v) that have the same value, can query remaining data's value is v.
1921 * @tc.type: FUNC
1922 * @tc.require: SR000CQDT4
1923 * @tc.author: fengxiaoyun
1924 */
1925 HWTEST_F(DistributeddbKvCreateTest, MergeRepeat001, TestSize.Level2)
1926 {
1927 KvStoreDelegateManager *manager = nullptr;
1928 KvStoreDelegate *result = nullptr;
1929 result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
1930 ASSERT_TRUE(manager != nullptr && result != nullptr);
1931
1932 /**
1933 * @tc.steps: step1. put 10 items of (keys,v) to db and GetKvStoreDiskSize() with storeId=store_Id_1.
1934 * @tc.expected: step1. put successfully and the GetKvStoreDiskSize() returns dbSize1.
1935 */
1936 uint64_t dbSize1, dbSize2;
1937 dbSize1 = dbSize2 = 0ul;
1938 EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize1), OK);
1939 vector<Entry> entriesBatch;
1940 vector<Key> allKeys;
1941 DistributedDB::Entry entry;
1942 int putCount = 0;
1943 entry.value.assign(TWO_M_LONG_STRING, 'v');
1944 GenerateTenThousandRecords(OPER_CNT_END, DEFAULT_START, allKeys, entriesBatch);
1945 for (vector<Entry>::iterator iter = entriesBatch.begin(); iter != entriesBatch.end(); iter++) {
1946 EXPECT_EQ(DistributedTestTools::Put(*result, iter->key, entry.value), OK);
1947 putCount++;
1948 }
1949
1950 /**
1951 * @tc.steps: step2. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1952 * @tc.expected: step2. call successfully and return dbSize2, dbSize2 > dbSize1.
1953 */
1954 EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize2), OK);
1955 EXPECT_TRUE(dbSize2 > dbSize1);
1956
1957 /**
1958 * @tc.steps: step3. delete the 10 items of (keys,v) except the sixth item.
1959 * @tc.expected: step3. operate successfully.
1960 */
1961 allKeys.erase(allKeys.begin() + FIVE_SECONDS);
1962 DBStatus statusDelete = DistributedTestTools::DeleteBatch(*result, allKeys);
1963 EXPECT_EQ(statusDelete, DBStatus::OK);
1964
1965 /**
1966 * @tc.steps: step4. Get(k6).
1967 * @tc.expected: step4. Get(k6)=v.
1968 */
1969 Value valueResult = DistributedTestTools::Get(*result, KEY_SEARCH_6);
1970 EXPECT_TRUE(valueResult.size() != 0);
1971 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, entry.value));
1972 EXPECT_EQ(manager->CloseKvStore(result), OK);
1973 result = nullptr;
1974 EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1975 delete manager;
1976 manager = nullptr;
1977 }
1978 #endif
1979 }
1980