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 <chrono>
18 #include <fstream>
19 #include <thread>
20
21 #include "db_constant.h"
22 #include "db_common.h"
23 #include "distributeddb_data_generate_unit_test.h"
24 #include "distributeddb_tools_unit_test.h"
25
26 using namespace testing::ext;
27 using namespace DistributedDB;
28 using namespace DistributedDBUnitTest;
29 using namespace std;
30
31 namespace {
32 // define some variables to init a KvStoreDelegateManager object.
33 KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
34 string g_testDir;
35 KvStoreConfig g_config;
36
37 // define the g_kvNbDelegateCallback, used to get some information when open a kv store.
38 DBStatus g_kvDelegateStatus = INVALID_ARGS;
39 KvStoreNbDelegate *g_kvNbDelegatePtr = nullptr;
40 KvStoreDelegate *g_kvDelegatePtr = nullptr;
41 KvStoreNbDelegate::Option g_nbOption;
42
43 // the type of g_kvNbDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
44 auto g_kvNbDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback, placeholders::_1,
45 placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvNbDelegatePtr));
46
47 // the type of g_kvDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
48 auto g_kvDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreDelegateCallback, placeholders::_1,
49 placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvDelegatePtr));
50
51 std::string g_storeId;
52 std::string g_identifier;
53 vector<string> g_singleVerFileNames;
54 vector<string> g_commitLogFileNames;
55 vector<string> g_metaStorageFileNames;
56 vector<string> g_multiVerDataFileNames;
57 vector<string> g_ValueStorageFileNames;
58
GetRealFileUrl()59 void GetRealFileUrl()
60 {
61 std::string origIdentifier = USER_ID + "-" + APP_ID + "-" + g_storeId;
62 std::string hashIdentifier = DBCommon::TransferHashString(origIdentifier);
63 g_identifier = DBCommon::TransferStringToHex(hashIdentifier);
64
65 g_singleVerFileNames = {
66 g_testDir + "/" + g_identifier + "/single_ver/main/gen_natural_store.db",
67 g_testDir + "/" + g_identifier + "/single_ver/main/gen_natural_store.db-shm",
68 g_testDir + "/" + g_identifier + "/single_ver/main/gen_natural_store.db-wal"};
69 g_commitLogFileNames = {
70 g_testDir + "/" + g_identifier + "/multi_ver/commit_logs.db",
71 g_testDir + "/" + g_identifier + "/multi_ver/commit_logs.db-shm",
72 g_testDir + "/" + g_identifier + "/multi_ver/commit_logs.db-wal"};
73 g_metaStorageFileNames = {
74 g_testDir + "/" + g_identifier + "/multi_ver/meta_storage.db",
75 g_testDir + "/" + g_identifier + "/multi_ver/meta_storage.db-shm",
76 g_testDir + "/" + g_identifier + "/multi_ver/meta_storage.db-wal"};
77 g_multiVerDataFileNames = {
78 g_testDir + "/" + g_identifier + "/multi_ver/multi_ver_data.db",
79 g_testDir + "/" + g_identifier + "/multi_ver/multi_ver_data.db-shm",
80 g_testDir + "/" + g_identifier + "/multi_ver/multi_ver_data.db-wal"};
81 g_ValueStorageFileNames = {
82 g_testDir + "/" + g_identifier + "/multi_ver/value_storage.db",
83 g_testDir + "/" + g_identifier + "/multi_ver/value_storage.db-shm",
84 g_testDir + "/" + g_identifier + "/multi_ver/value_storage.db-wal"};
85 }
86
GetMultiVerFilelist()87 vector<string> GetMultiVerFilelist()
88 {
89 vector<string> multiFileNames;
90 for (const auto &iter : g_commitLogFileNames) {
91 multiFileNames.push_back(iter);
92 }
93 for (const auto &iter : g_metaStorageFileNames) {
94 multiFileNames.push_back(iter);
95 }
96 for (const auto &iter : g_multiVerDataFileNames) {
97 multiFileNames.push_back(iter);
98 }
99 for (const auto &iter : g_ValueStorageFileNames) {
100 multiFileNames.push_back(iter);
101 }
102 return multiFileNames;
103 }
104 }
105
106 class DistributedDBInterfacesSpaceManagementTest : public testing::Test {
107 public:
108 static void SetUpTestCase(void);
109 static void TearDownTestCase(void);
110 void SetUp();
111 void TearDown();
112 };
113
SetUpTestCase(void)114 void DistributedDBInterfacesSpaceManagementTest::SetUpTestCase(void)
115 {
116 DistributedDBToolsUnitTest::TestDirInit(g_testDir);
117 g_config.dataDir = g_testDir;
118 g_mgr.SetKvStoreConfig(g_config);
119 }
120
TearDownTestCase(void)121 void DistributedDBInterfacesSpaceManagementTest::TearDownTestCase(void)
122 {
123 if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
124 LOGE("rm test db files error!");
125 }
126 }
127
SetUp(void)128 void DistributedDBInterfacesSpaceManagementTest::SetUp(void)
129 {
130 DistributedDBToolsUnitTest::PrintTestCaseInfo();
131 g_kvDelegateStatus = INVALID_ARGS;
132 g_kvNbDelegatePtr = nullptr;
133 g_kvDelegatePtr = nullptr;
134 }
135
TearDown(void)136 void DistributedDBInterfacesSpaceManagementTest::TearDown(void) {}
137
138 // use another way calculate small file size(2G)
CheckRealFileSize(const vector<string> & fileNames)139 static uint64_t CheckRealFileSize(const vector<string> &fileNames)
140 {
141 uint64_t size = 0;
142 for (const auto &file : fileNames) {
143 FILE *fileHandle = nullptr;
144 fileHandle = fopen(file.c_str(), "rb");
145 if (fileHandle == nullptr) {
146 LOGE("Open file[%s] fail[%d]", file.c_str(), errno);
147 continue;
148 }
149 (void)fseek(fileHandle, 0, SEEK_END);
150 long fileSize = ftell(fileHandle);
151 LOGD("CheckRealFileSize:FileName[%s],size[%ld]", file.c_str(), fileSize);
152 size += static_cast<uint64_t>(fileSize); // file is less than 16M.
153 (void)fclose(fileHandle);
154 }
155 return size;
156 }
157
158 /**
159 * @tc.name: GetKvStoreDiskSize001
160 * @tc.desc: ROM space occupied by applications in the distributed database can be calculated.
161 * @tc.type: FUNC
162 * @tc.require: AR000CQDTD
163 * @tc.author: sunpeng
164 */
165 HWTEST_F(DistributedDBInterfacesSpaceManagementTest, GetKvStoreDiskSize001, TestSize.Level1)
166 {
167 g_storeId = "distributed_GetKvStoreDiskSize_001";
168 GetRealFileUrl();
169
170 g_mgr.GetKvStore(g_storeId, g_nbOption, g_kvNbDelegateCallback);
171 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
172 EXPECT_TRUE(g_kvDelegateStatus == OK);
173
174 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
175
176 /**
177 * @tc.steps: step1/2. Get Db size by GetKvStoreDiskSize.
178 * @tc.expected: step1/2. Return right size and ok.
179 */
180 uint64_t localDbSize = 0;
181 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, localDbSize), OK);
182 EXPECT_EQ(CheckRealFileSize(g_singleVerFileNames), localDbSize);
183
184 /**
185 * @tc.steps: step3. Reopen Db.
186 */
187 g_mgr.GetKvStore(g_storeId, g_nbOption, g_kvNbDelegateCallback);
188 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
189 EXPECT_TRUE(g_kvDelegateStatus == OK);
190
191 /**
192 * @tc.steps: step4. Put some Key Value to change Db size.
193 */
194 Key key;
195 Value value;
196 DistributedDBToolsUnitTest::GetRandomKeyValue(key, DBConstant::MAX_KEY_SIZE);
197 DistributedDBToolsUnitTest::GetRandomKeyValue(value, DBConstant::MAX_VALUE_SIZE);
198 EXPECT_EQ(g_kvNbDelegatePtr->Put(key, value), OK);
199
200 /**
201 * @tc.steps: step5/6. Get Db size by GetKvStoreDiskSize.
202 * @tc.expected: step5/6. Return right size and ok.
203 */
204 localDbSize = 0;
205 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, localDbSize), OK);
206 EXPECT_EQ(CheckRealFileSize(g_singleVerFileNames), localDbSize);
207
208 /**
209 * @tc.steps: step7. Close and Delete Db.
210 * @tc.expected: step7. Successfully.
211 */
212 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
213 EXPECT_EQ(g_mgr.DeleteKvStore(g_storeId), OK);
214 }
215
216 /**
217 * @tc.name: GetKvStoreDiskSize002
218 * @tc.desc: Obtain the size of the opened database.
219 * @tc.type: FUNC
220 * @tc.require: AR000CQDTD
221 * @tc.author: sunpeng
222 */
223 HWTEST_F(DistributedDBInterfacesSpaceManagementTest, GetKvStoreDiskSize002, TestSize.Level2)
224 {
225 g_storeId = "distributed_GetKvStoreDiskSize_002";
226 GetRealFileUrl();
227
228 KvStoreDelegate::Option option;
229 g_mgr.GetKvStore(g_storeId, option, g_kvDelegateCallback);
230 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
231 EXPECT_TRUE(g_kvDelegateStatus == OK);
232 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
233
234 g_mgr.GetKvStore(g_storeId, g_nbOption, g_kvNbDelegateCallback);
235 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
236 EXPECT_TRUE(g_kvDelegateStatus == OK);
237
238 /**
239 * @tc.steps: step1/2. Get Db size by GetKvStoreDiskSize.
240 * @tc.expected: step1/2. Return right size and ok.
241 */
242 uint64_t singleAndMultiDbSize = 0;
243 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleAndMultiDbSize), OK);
244 uint64_t dbSizeForCheck = CheckRealFileSize(g_singleVerFileNames) + CheckRealFileSize(GetMultiVerFilelist());
245 EXPECT_EQ(dbSizeForCheck, singleAndMultiDbSize);
246
247 Key key;
248 Value value;
249 DistributedDBToolsUnitTest::GetRandomKeyValue(key, DBConstant::MAX_KEY_SIZE);
250 DistributedDBToolsUnitTest::GetRandomKeyValue(value, DBConstant::MAX_VALUE_SIZE);
251
252 EXPECT_EQ(g_kvNbDelegatePtr->Put(key, value), OK);
253 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
254
255 /**
256 * @tc.steps: step3/4. Reopen Db and Put some Key Value to change Db size.
257 */
258 g_mgr.GetKvStore(g_storeId, option, g_kvDelegateCallback);
259 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
260 EXPECT_TRUE(g_kvDelegateStatus == OK);
261 EXPECT_EQ(g_kvDelegatePtr->Put(key, value), OK);
262
263 /**
264 * @tc.steps: step5/6. Get Db size by GetKvStoreDiskSize.
265 * @tc.expected: step5/6. Return right size and ok.
266 */
267 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // for vacuum
268 singleAndMultiDbSize = 0;
269 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleAndMultiDbSize), OK);
270 ASSERT_TRUE(dbSizeForCheck != singleAndMultiDbSize);
271 dbSizeForCheck = CheckRealFileSize(g_singleVerFileNames) + CheckRealFileSize(GetMultiVerFilelist());
272 EXPECT_EQ(dbSizeForCheck, singleAndMultiDbSize);
273 LOGE("single:%" PRIu64 ",mul:%" PRIu64, CheckRealFileSize(g_singleVerFileNames),
274 CheckRealFileSize(GetMultiVerFilelist()));
275
276 /**
277 * @tc.steps: step7. Close and Delete Db.
278 * @tc.expected: step7. Successfully.
279 */
280 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
281 EXPECT_EQ(g_mgr.DeleteKvStore(g_storeId), OK);
282 }
283
284 // The file will be deleted after the test, it only for test, no security impact on permissions
CreateFile(const std::string & fileUrl,uint64_t fileSize)285 static void CreateFile(const std::string &fileUrl, uint64_t fileSize)
286 {
287 ofstream mcfile;
288 mcfile.open(fileUrl);
289 if (!mcfile.is_open()) {
290 return;
291 }
292 std::string fileContext;
293 fileContext.resize(fileSize, 'X');
294 mcfile << fileContext;
295 mcfile.close();
296 return;
297 }
298
DeleteFile(const std::string & fileUrl)299 static void DeleteFile(const std::string &fileUrl)
300 {
301 std::ifstream walFile(fileUrl);
302 if (walFile) {
303 int result = remove(fileUrl.c_str());
304 if (result < 0) {
305 LOGE("failed to delete the file[%s]:%d", fileUrl.c_str(), errno);
306 }
307 }
308 return;
309 }
310
311 /**
312 * @tc.name: GetKvStoreDiskSize003
313 * @tc.desc: Verification exception parameters
314 * @tc.type: FUNC
315 * @tc.require: AR000CQDTD
316 * @tc.author: sunpeng
317 */
318 HWTEST_F(DistributedDBInterfacesSpaceManagementTest, GetKvStoreDiskSize003, TestSize.Level1)
319 {
320 g_storeId = "distributed_GetKvStoreDiskSize_003";
321 GetRealFileUrl();
322 KvStoreNbDelegate::Option nbOption;
323 g_mgr.GetKvStore(g_storeId, nbOption, g_kvNbDelegateCallback);
324 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
325 EXPECT_TRUE(g_kvDelegateStatus == OK);
326 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
327
328 KvStoreDelegate::Option option;
329 g_mgr.GetKvStore(g_storeId, option, g_kvDelegateCallback);
330 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
331 EXPECT_TRUE(g_kvDelegateStatus == OK);
332
333 /**
334 * @tc.steps: step1. Use an anomalous length of storeId by GetKvStoreDiskSize to get size.
335 * @tc.expected: step1. Return 0 size and INVALID_ARGS.
336 */
337 uint64_t dbSize = 0;
338 std::string exceptStoreId;
339 exceptStoreId.clear();
340 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(exceptStoreId, dbSize), INVALID_ARGS);
341 EXPECT_EQ(dbSize, 0ull);
342
343 exceptStoreId.resize(129, 'X');
344 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(exceptStoreId, dbSize), INVALID_ARGS);
345 EXPECT_EQ(dbSize, 0ull);
346
347 /**
348 * @tc.steps: step2. Use a valid but not exist storeId to GetKvStoreDiskSize.
349 * @tc.expected: step2. Return 0 size and NOT_FOUND.
350 */
351 exceptStoreId.resize(128, 'X');
352 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(exceptStoreId, dbSize), NOT_FOUND);
353 EXPECT_EQ(dbSize, 0ull);
354
355 /**
356 * @tc.steps: step3/4. Use right storeId to GetKvStoreDiskSize.
357 * @tc.expected: step3/4. Return right size and OK.
358 */
359 uint64_t singleAndMultiDbSize = 0;
360 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleAndMultiDbSize), OK);
361 uint64_t dbSizeForCheck = CheckRealFileSize(g_singleVerFileNames) + CheckRealFileSize(GetMultiVerFilelist());
362 EXPECT_EQ(dbSizeForCheck, singleAndMultiDbSize);
363
364 /**
365 * @tc.steps: step5. Create irrelevant files.
366 */
367 CreateFile(g_testDir + "/" + g_storeId + "/" + DBConstant::MULTI_SUB_DIR + "/test.txt", 1024 * 1024);
368
369 /**
370 * @tc.steps: step6/7/8. Get Db size by GetKvStoreDiskSize.
371 * @tc.expected: step6/7/8. Return right size and ok.
372 */
373 singleAndMultiDbSize = 0;
374 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleAndMultiDbSize), OK);
375 EXPECT_EQ(dbSizeForCheck, singleAndMultiDbSize);
376
377 DeleteFile(g_testDir + "/" + g_storeId + "/" + DBConstant::MULTI_SUB_DIR + "/test.txt");
378 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
379 EXPECT_EQ(g_mgr.DeleteKvStore(g_storeId), OK);
380 }
381
382 /**
383 * @tc.name: GetKvStoreDiskSize004
384 * @tc.desc: Calculate memory database size
385 * @tc.type: FUNC
386 * @tc.require: AR000CQDTD
387 * @tc.author: sunpeng
388 */
389 HWTEST_F(DistributedDBInterfacesSpaceManagementTest, GetKvStoreDiskSize004, TestSize.Level1)
390 {
391 g_storeId = "distributed_GetKvStoreDiskSize_004";
392 GetRealFileUrl();
393
394 KvStoreNbDelegate::Option nbOption;
395 g_mgr.GetKvStore(g_storeId, nbOption, g_kvNbDelegateCallback);
396 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
397 EXPECT_TRUE(g_kvDelegateStatus == OK);
398 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
399 uint64_t singleVerRealSize = CheckRealFileSize(g_singleVerFileNames);
400
401 /**
402 * @tc.steps: step1/2. Get Db size by GetKvStoreDiskSize.
403 * @tc.expected: step1/2. Return right size and ok.
404 */
405 uint64_t singleVerDbSize = 0;
406 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleVerDbSize), OK);
407 EXPECT_EQ(singleVerDbSize, singleVerRealSize);
408
409 /**
410 * @tc.steps: step3. Use the same storeId create memoryDb.
411 */
412 nbOption = {true, true};
413 g_mgr.GetKvStore(g_storeId, nbOption, g_kvNbDelegateCallback);
414 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
415 EXPECT_TRUE(g_kvDelegateStatus == OK);
416
417 /**
418 * @tc.steps: step4/5. Get Db size by GetKvStoreDiskSize.
419 * @tc.expected: step4/5. Return 0 size and ok.
420 */
421 singleVerDbSize = 0;
422 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleVerDbSize), OK);
423 EXPECT_EQ(singleVerDbSize, 0ull);
424
425 /**
426 * @tc.steps: step6. Close memoryDb.
427 */
428 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
429
430 /**
431 * @tc.steps: step7. Get Db size by GetKvStoreDiskSize.
432 * @tc.expected: step7. Return right size and ok.
433 */
434 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(g_storeId, singleVerDbSize), OK);
435 EXPECT_EQ(singleVerDbSize, singleVerRealSize);
436
437 EXPECT_EQ(g_mgr.DeleteKvStore(g_storeId), OK);
438 }
439
440 /**
441 * @tc.name: DeleteDbByStoreId001
442 * @tc.desc: Delete database by storeId.
443 * @tc.type: FUNC
444 * @tc.require: AR000CQDTD
445 * @tc.author: sunpeng
446 */
447 HWTEST_F(DistributedDBInterfacesSpaceManagementTest, DeleteDbByStoreId001, TestSize.Level1)
448 {
449 std::string storeId1 = "distributed_DeleteDbByStoreId001";
450 KvStoreNbDelegate::Option nbOption;
451 g_mgr.GetKvStore(storeId1, nbOption, g_kvNbDelegateCallback);
452 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
453 EXPECT_TRUE(g_kvDelegateStatus == OK);
454 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
455 KvStoreDelegate::Option option;
456 g_mgr.GetKvStore(storeId1, option, g_kvDelegateCallback);
457 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
458 EXPECT_TRUE(g_kvDelegateStatus == OK);
459 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
460 option.localOnly = true;
461 g_mgr.GetKvStore(storeId1, option, g_kvDelegateCallback);
462 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
463 EXPECT_TRUE(g_kvDelegateStatus == OK);
464 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
465
466 std::string storeId2 = "distributed_DeleteDbByStoreId002";
467
468 g_mgr.GetKvStore(storeId2, nbOption, g_kvNbDelegateCallback);
469 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
470 EXPECT_TRUE(g_kvDelegateStatus == OK);
471 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
472 option.localOnly = false;
473 g_mgr.GetKvStore(storeId2, option, g_kvDelegateCallback);
474 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
475 EXPECT_TRUE(g_kvDelegateStatus == OK);
476 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
477 option.localOnly = true;
478 g_mgr.GetKvStore(storeId2, option, g_kvDelegateCallback);
479 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
480 EXPECT_TRUE(g_kvDelegateStatus == OK);
481 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
482
483 uint64_t store1DbSize = 0;
484 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(storeId1, store1DbSize), OK);
485 EXPECT_NE(store1DbSize, 0ull);
486 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(storeId2, store1DbSize), OK);
487 EXPECT_NE(store1DbSize, 0ull);
488
489 /**
490 * @tc.steps: step1. Delete database by storeId 1.
491 */
492 EXPECT_EQ(g_mgr.DeleteKvStore(storeId1), OK);
493
494 /**
495 * @tc.steps: step2. Use storeId 1 to get Db size by GetKvStoreDiskSize.
496 * @tc.expected: step2. Return 0 size and ok.
497 */
498 store1DbSize = 0;
499 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(storeId1, store1DbSize), NOT_FOUND);
500 EXPECT_EQ(store1DbSize, 0ull);
501
502 /**
503 * @tc.steps: step3. Use storeId 2 to get Db size by GetKvStoreDiskSize.
504 * @tc.expected: step3. Return right size and ok.
505 */
506 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(storeId2, store1DbSize), OK);
507 EXPECT_NE(store1DbSize, 0ull);
508 }
509
510 /**
511 * @tc.name: DeleteDbByStoreId002
512 * @tc.desc: Delete database by not exist storeId.
513 * @tc.type: FUNC
514 * @tc.require: AR000CQDTD
515 * @tc.author: sunpeng
516 */
517 HWTEST_F(DistributedDBInterfacesSpaceManagementTest, DeleteDbByStoreId002, TestSize.Level1)
518 {
519 std::string storeId1 = "distributed_DeleteDbByStoreId001";
520
521 uint64_t store1DbSize = 0;
522 EXPECT_EQ(g_mgr.GetKvStoreDiskSize(storeId1, store1DbSize), NOT_FOUND);
523 EXPECT_EQ(store1DbSize, 0ull);
524
525 /**
526 * @tc.steps: step1. Delete database by not exist storeId 1.
527 * @tc.expected: step3. Return NOT_FOUND.
528 */
529 EXPECT_EQ(g_mgr.DeleteKvStore(storeId1), NOT_FOUND);
530 }
531