1 /*
2 * Copyright (c) 2024 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
17 #include <filesystem>
18 #include <sys/stat.h>
19
20 #include "db_errno.h"
21 #include "distributeddb_tools_unit_test.h"
22 #include "kvdb_properties.h"
23 #include "log_print.h"
24 #include "single_ver_database_oper.h"
25 #include "storage_engine_manager.h"
26 #include "platform_specific.h"
27
28 using namespace testing::ext;
29 using namespace DistributedDB;
30 using namespace DistributedDBUnitTest;
31 using namespace testing;
32
33 namespace {
34 class DistributedDBStorageSingleVerDatabaseOperTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40 protected:
41 std::string testDir_;
42 std::string currentDir_;
43 std::string unpackedDir_;
44 std::vector<std::string> unpackedDirs_;
45 SQLiteSingleVerNaturalStore *singleVerNaturalStore_ = nullptr;
46 SQLiteSingleVerStorageEngine *singleVerStorageEngine_ = nullptr;
47 };
48
SetUpTestCase(void)49 void DistributedDBStorageSingleVerDatabaseOperTest::SetUpTestCase(void)
50 {
51 }
52
TearDownTestCase(void)53 void DistributedDBStorageSingleVerDatabaseOperTest::TearDownTestCase(void)
54 {
55 }
56
SetUp(void)57 void DistributedDBStorageSingleVerDatabaseOperTest::SetUp(void)
58 {
59 DistributedDBToolsUnitTest::PrintTestCaseInfo();
60 DistributedDBToolsUnitTest::TestDirInit(testDir_);
61 singleVerNaturalStore_ = new (std::nothrow) SQLiteSingleVerNaturalStore();
62 ASSERT_NE(singleVerNaturalStore_, nullptr);
63 KvDBProperties property;
64 property.SetStringProp(KvDBProperties::DATA_DIR, "");
65 property.SetStringProp(KvDBProperties::STORE_ID, "TestDatabaseOper");
66 property.SetStringProp(KvDBProperties::IDENTIFIER_DIR, "TestDatabaseOper");
67 property.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
68 int errCode = E_OK;
69 singleVerStorageEngine_ =
70 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(property, errCode));
71 ASSERT_EQ(errCode, E_OK);
72 ASSERT_NE(singleVerStorageEngine_, nullptr);
73 currentDir_ = this->testDir_ + "/current";
74 EXPECT_EQ(mkdir(currentDir_.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)), E_OK);
75 this->unpackedDirs_.push_back(currentDir_);
76 unpackedDir_ = this->testDir_ + "/unpacked_old";
77 EXPECT_EQ(mkdir(unpackedDir_.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)), E_OK);
78 this->unpackedDirs_.push_back(unpackedDir_);
79 }
80
TearDown(void)81 void DistributedDBStorageSingleVerDatabaseOperTest::TearDown(void)
82 {
83 for (const auto& dir : unpackedDirs_) {
84 if (std::filesystem::exists(dir)) {
85 std::filesystem::remove_all(dir);
86 }
87 }
88 delete singleVerNaturalStore_;
89 singleVerNaturalStore_ = nullptr;
90 singleVerStorageEngine_ = nullptr;
91 if (DistributedDBToolsUnitTest::RemoveTestDbFiles(testDir_) != E_OK) {
92 LOGE("rm test db files error.");
93 }
94 }
95
96 /**
97 * @tc.name: DatabaseOperationTest001
98 * @tc.desc: test Rekey, Import and Export interface in abnormal condition
99 * @tc.type: FUNC
100 * @tc.require:
101 * @tc.author: chenchaohao
102 */
103 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, DatabaseOperationTest001, TestSize.Level0)
104 {
105 /**
106 * @tc.steps: step1. Create singleVerDatabaseOper with nullptr;
107 * @tc.expected: OK.
108 */
109 std::unique_ptr<SingleVerDatabaseOper> singleVerDatabaseOper =
110 std::make_unique<SingleVerDatabaseOper>(singleVerNaturalStore_, nullptr);
111 ASSERT_NE(singleVerDatabaseOper, nullptr);
112
113 /**
114 * @tc.steps: step2. Test Rekey, Import and Export interface;
115 * @tc.expected: OK.
116 */
117 CipherPassword passwd;
118 EXPECT_EQ(singleVerDatabaseOper->Rekey(passwd), -E_INVALID_DB);
119 EXPECT_EQ(singleVerDatabaseOper->Import("", passwd), -E_INVALID_DB);
120 EXPECT_EQ(singleVerDatabaseOper->Export("", passwd), -E_INVALID_DB);
121 KvDBProperties properties;
122 EXPECT_EQ(singleVerDatabaseOper->RekeyRecover(properties), -E_INVALID_ARGS);
123 EXPECT_EQ(singleVerDatabaseOper->ClearImportTempFile(properties), -E_INVALID_ARGS);
124 EXPECT_EQ(singleVerDatabaseOper->ClearExportedTempFiles(properties), -E_INVALID_ARGS);
125 }
126
127 /**
128 * @tc.name: DatabaseOperationTest002
129 * @tc.desc: test Import and Export interface in abnormal condition
130 * @tc.type: FUNC
131 * @tc.require:
132 * @tc.author: chenchaohao
133 */
134 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, DatabaseOperationTest002, TestSize.Level0)
135 {
136 /**
137 * @tc.steps: step1. Create singleVerDatabaseOper;
138 * @tc.expected: OK.
139 */
140 std::unique_ptr<SingleVerDatabaseOper> singleVerDatabaseOper =
141 std::make_unique<SingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
142 ASSERT_NE(singleVerDatabaseOper, nullptr);
143
144 /**
145 * @tc.steps: step2. Test Import and Export interface;
146 * @tc.expected: OK.
147 */
148 CipherPassword passwd;
149 EXPECT_EQ(singleVerDatabaseOper->Export("", passwd), -E_NOT_INIT);
150 singleVerDatabaseOper->SetLocalDevId("device");
151 EXPECT_EQ(singleVerDatabaseOper->Export("", passwd), -E_INVALID_ARGS);
152 }
153
154 /**
155 * @tc.name: DatabaseOperationTest003
156 * @tc.desc: test RecoverPrehandle
157 * @tc.type: FUNC
158 * @tc.require:
159 * @tc.author: tiansimiao
160 */
161 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, DatabaseOperationTest003, TestSize.Level0)
162 {
163 std::unique_ptr<SingleVerDatabaseOper> singleVerDatabaseOper =
164 std::make_unique<SingleVerDatabaseOper>(singleVerNaturalStore_, nullptr);
165 ASSERT_NE(singleVerDatabaseOper, nullptr);
166
167 KvDBProperties validProperty;
168 validProperty.SetStringProp(KvDBProperties::DATA_DIR, testDir_);
169 validProperty.SetStringProp(KvDBProperties::STORE_ID, "TestRecoverPrehandleError");
170 validProperty.SetStringProp(KvDBProperties::IDENTIFIER_DIR, "TestRecoverPrehandleError");
171 validProperty.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
172 // prepare file
173 std::string dbSubDir = KvDBProperties::GetStoreSubDirectory
174 (validProperty.GetIntProp(KvDBProperties::DATABASE_TYPE, 0));
175 std::string workDir = testDir_ + "/" + validProperty.GetStringProp(KvDBProperties::IDENTIFIER_DIR, "");
176 std::string preCtrlFileName = workDir + "/" + dbSubDir + DBConstant::REKEY_FILENAME_POSTFIX_PRE;
177 std::string backupDir = workDir + "/" + dbSubDir + DBConstant::PATH_BACKUP_POSTFIX;
178 // Create the preCtrlFile and backupDir
179 EXPECT_EQ(OS::MakeDBDirectory(workDir), E_OK);
180 EXPECT_EQ(OS::MakeDBDirectory(workDir + "/" + dbSubDir), E_OK);
181 EXPECT_EQ(OS::MakeDBDirectory(backupDir), E_OK);
182 std::string testFile1 = backupDir + "/test1.txt";
183 std::string testFile2 = backupDir + "/test2.txt";
184 DistributedDB::OS::FileHandle* fileHandle1 = nullptr;
185 DistributedDB::OS::FileHandle* fileHandle2 = nullptr;
186 DistributedDB::OS::FileHandle* preCtrlHandle = nullptr;
187 EXPECT_EQ(OS::OpenFile(testFile1, fileHandle1), E_OK);
188 if (fileHandle1 != nullptr) {
189 OS::CloseFile(fileHandle1);
190 fileHandle1 = nullptr;
191 }
192 EXPECT_EQ(OS::OpenFile(testFile2, fileHandle2), E_OK);
193 if (fileHandle2 != nullptr) {
194 OS::CloseFile(fileHandle2);
195 fileHandle2 = nullptr;
196 }
197 EXPECT_EQ(OS::OpenFile(preCtrlFileName, preCtrlHandle), E_OK);
198 if (preCtrlHandle != nullptr) {
199 OS::CloseFile(preCtrlHandle);
200 preCtrlHandle = nullptr;
201 }
202 EXPECT_EQ(singleVerDatabaseOper->RekeyRecover(validProperty), E_OK);
203 }
204
205 /**
206 * @tc.name: DatabaseOperationTest004
207 * @tc.desc: Test Rekey, Import and Export interface in abnormal condition
208 * @tc.type: FUNC
209 * @tc.require:
210 * @tc.author: tiansimiao
211 */
212 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, DatabaseOperationTest004, TestSize.Level0)
213 {
214 /**
215 * @tc.steps: step1. Create singleVerDatabaseOper with singleVerNaturalStore_ nullptr;
216 * @tc.expected: OK.
217 */
218 std::unique_ptr<SingleVerDatabaseOper> singleVerDatabaseOper =
219 std::make_unique<SingleVerDatabaseOper>(nullptr, singleVerStorageEngine_);
220 ASSERT_NE(singleVerDatabaseOper, nullptr);
221
222 /**
223 * @tc.steps: step2. Test Rekey, Import and Export interface;
224 * @tc.expected: E_INVALID_DB.
225 */
226 CipherPassword passwd;
227 EXPECT_EQ(singleVerDatabaseOper->Rekey(passwd), -E_INVALID_DB);
228 EXPECT_EQ(singleVerDatabaseOper->Import("", passwd), -E_INVALID_DB);
229 EXPECT_EQ(singleVerDatabaseOper->Export("", passwd), -E_INVALID_DB);
230 }
231
232 class TestableSingleVerDatabaseOper : public DistributedDB::SingleVerDatabaseOper {
233 public:
234 using SingleVerDatabaseOper::RekeyPreHandle;
235 using SingleVerDatabaseOper::ImportUnpackedDatabase;
236 using SingleVerDatabaseOper::BackupDb;
237 using SingleVerDatabaseOper::CloseStorages;
238 using SingleVerDatabaseOper::ExportAllDatabases;
TestableSingleVerDatabaseOper(DistributedDB::SQLiteSingleVerNaturalStore * naturalStore,DistributedDB::SQLiteStorageEngine * StorageEngine)239 TestableSingleVerDatabaseOper(DistributedDB::SQLiteSingleVerNaturalStore *naturalStore,
240 DistributedDB::SQLiteStorageEngine *StorageEngine) : SingleVerDatabaseOper(naturalStore, StorageEngine) {}
241 };
242
243 /**
244 * @tc.name: BackupDbTest001
245 * @tc.desc: test BackupDb function in abnormal condition
246 * @tc.type: FUNC
247 * @tc.require:
248 * @tc.author: tiansimiao
249 */
250 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, BackupDbTest001, TestSize.Level0)
251 {
252 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
253 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
254 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
255 CipherPassword passwd;
256 EXPECT_EQ(testSingleVerDatabaseOper->BackupDb(passwd), -E_INVALID_ARGS);
257 }
258
259 /**
260 * @tc.name: CloseStoragesTest001
261 * @tc.desc: test CloseStorages function in abnormal condition
262 * @tc.type: FUNC
263 * @tc.require:
264 * @tc.author: tiansimiao
265 */
266 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, CloseStoragesTest001, TestSize.Level0)
267 {
268 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
269 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
270 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
271 EXPECT_EQ(testSingleVerDatabaseOper->CloseStorages(), -E_INVALID_ARGS);
272 }
273
274 /**
275 * @tc.name: ExportMainDBTest001
276 * @tc.desc: test ExportMainDB function in abnormal condition
277 * @tc.type: FUNC
278 * @tc.require:
279 * @tc.author: tiansimiao
280 */
281 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ExportMainDBTest001, TestSize.Level0)
282 {
283 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
284 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
285 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
286 std::string dbDir = "invalidDbDir";
287 CipherPassword passwd;
288 EXPECT_EQ(testSingleVerDatabaseOper->ExportAllDatabases(currentDir_, passwd, dbDir), -E_SQLITE_CANT_OPEN);
289 }
290
291 /**
292 * @tc.name: ImportUnpackedDatabaseTest001
293 * @tc.desc: ClearCurrentDatabase failed
294 * @tc.type: FUNC
295 * @tc.require:
296 * @tc.author: tiansimiao
297 */
298 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedDatabaseTest001, TestSize.Level0)
299 {
300 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
301 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
302 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
303 std::string current = this->testDir_ + "/nonexist";
304 CipherPassword passwd;
305 DistributedDB::ImportFileInfo info;
306 info.currentDir = current;
307 info.unpackedDir = unpackedDir_;
308 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, true), -E_SYSTEM_API_FAIL);
309 }
310
311 /**
312 * @tc.name: ImportUnpackedMainDatabaseTest001
313 * @tc.desc: Test OldMainDbExisted and export the unpacked old version(<3) main database to current error.
314 * @tc.type: FUNC
315 * @tc.require:
316 * @tc.author: tiansimiao
317 */
318 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedMainDatabaseTest001, TestSize.Level0)
319 {
320 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
321 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
322 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
323 std::string oldMainFile = unpackedDir_ + "/gen_natural_store.db";
324 std::ofstream outFile(oldMainFile.c_str(), std::ios::out | std::ios::binary);
325 ASSERT_TRUE(outFile.is_open());
326 outFile.close();
327 CipherPassword passwd;
328 DistributedDB::ImportFileInfo info;
329 info.currentDir = currentDir_;
330 info.unpackedDir = unpackedDir_;
331 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, true), -E_INVALID_FILE);
332 }
333
334 /**
335 * @tc.name: ImportUnpackedMainDatabaseTest002
336 * @tc.desc: Test MainDbExisted and export the unpacked main database to current error.
337 * @tc.type: FUNC
338 * @tc.require:
339 * @tc.author: tiansimiao
340 */
341 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedMainDatabaseTest002, TestSize.Level0)
342 {
343 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
344 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
345 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
346 std::string mainDir = unpackedDir_ + "main";
347 EXPECT_EQ(mkdir(mainDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)), E_OK);
348 this->unpackedDirs_.push_back(mainDir);
349 std::string mainFile = mainDir + "/gen_natural_store.db";
350 std::ofstream outFile(mainFile.c_str(), std::ios::out | std::ios::binary);
351 ASSERT_TRUE(outFile.is_open());
352 outFile.close();
353 CipherPassword passwd;
354 DistributedDB::ImportFileInfo info;
355 info.currentDir = currentDir_;
356 info.unpackedDir = unpackedDir_;
357 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, true), -E_INVALID_FILE);
358 }
359
360 /**
361 * @tc.name: ImportUnpackedMainDatabaseTest003
362 * @tc.desc: Test MainDbExisted and check main file integrity error.
363 * @tc.type: FUNC
364 * @tc.require:
365 * @tc.author: tiansimiao
366 */
367 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedMainDatabaseTest003, TestSize.Level0)
368 {
369 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
370 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
371 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
372 std::string mainDir = unpackedDir_ + "main";
373 EXPECT_EQ(mkdir(mainDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)), E_OK);
374 this->unpackedDirs_.push_back(mainDir);
375 std::string mainFile = mainDir + "/gen_natural_store.db";
376 std::ofstream outFile(mainFile.c_str(), std::ios::out | std::ios::binary);
377 ASSERT_TRUE(outFile.is_open());
378 outFile.close();
379 EXPECT_EQ(chmod(mainFile.c_str(), S_IRUSR | S_IRGRP | S_IROTH), E_OK);
380 CipherPassword passwd;
381 DistributedDB::ImportFileInfo info;
382 info.currentDir = currentDir_;
383 info.unpackedDir = unpackedDir_;
384 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, true), -E_INVALID_FILE);
385 }
386
387 /**
388 * @tc.name: ImportUnpackedMainDatabaseTest004
389 * @tc.desc: Test OldMainDbExisted and check main file integrity error.
390 * @tc.type: FUNC
391 * @tc.require:
392 * @tc.author: tiansimiao
393 */
394 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedMainDatabaseTest004, TestSize.Level0)
395 {
396 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
397 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
398 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
399 std::string oldMainFile = unpackedDir_ + "/gen_natural_store.db";
400 std::ofstream outFile(oldMainFile.c_str(), std::ios::out | std::ios::binary);
401 ASSERT_TRUE(outFile.is_open());
402 outFile.close();
403 EXPECT_EQ(chmod(oldMainFile.c_str(), S_IRUSR | S_IRGRP | S_IROTH), E_OK);
404 CipherPassword passwd;
405 DistributedDB::ImportFileInfo info;
406 info.currentDir = currentDir_;
407 info.unpackedDir = unpackedDir_;
408 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, true), -E_INVALID_FILE);
409 }
410
411 /**
412 * @tc.name: ImportUnpackedMainDatabaseTest005
413 * @tc.desc: Test OldMainDbExisted and no need to check integrity.
414 * @tc.type: FUNC
415 * @tc.require:
416 * @tc.author: tiansimiao
417 */
418 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedMainDatabaseTest005, TestSize.Level0)
419 {
420 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
421 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
422 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
423 std::string oldMainFile = unpackedDir_ + "/gen_natural_store.db";
424 std::ofstream outFile(oldMainFile.c_str(), std::ios::out | std::ios::binary);
425 ASSERT_TRUE(outFile.is_open());
426 outFile.close();
427 CipherPassword passwd;
428 DistributedDB::ImportFileInfo info;
429 info.currentDir = currentDir_;
430 info.unpackedDir = unpackedDir_;
431 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, false), -E_INVALID_FILE);
432 }
433
434 /**
435 * @tc.name: ImportUnpackedMetaDatabaseTest001
436 * @tc.desc: Test ImportUnpackedMetaDatabase func.
437 * @tc.type: FUNC
438 * @tc.require:
439 * @tc.author: tiansimiao
440 */
441 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, ImportUnpackedMetaDatabaseTest001, TestSize.Level0)
442 {
443 std::unique_ptr<TestableSingleVerDatabaseOper> testSingleVerDatabaseOper =
444 std::make_unique<TestableSingleVerDatabaseOper>(singleVerNaturalStore_, singleVerStorageEngine_);
445 ASSERT_NE(testSingleVerDatabaseOper, nullptr);
446 std::string metaDir = unpackedDir_ + "meta";
447 EXPECT_EQ(mkdir(metaDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)), E_OK);
448 this->unpackedDirs_.push_back(metaDir);
449 std::string metaFile = metaDir + "/meta.db";
450 std::ofstream outFile(metaFile.c_str(), std::ios::out | std::ios::binary);
451 ASSERT_TRUE(outFile.is_open());
452 outFile.close();
453 CipherPassword passwd;
454 DistributedDB::ImportFileInfo info;
455 info.currentDir = currentDir_;
456 info.unpackedDir = unpackedDir_;
457 EXPECT_EQ(testSingleVerDatabaseOper->ImportUnpackedDatabase(info, passwd, false), -E_INVALID_FILE);
458 }
459
460 /**
461 * @tc.name: GetStoreSubDirectoryTest001
462 * @tc.desc: test different type
463 * @tc.type: FUNC
464 * @tc.require:
465 * @tc.author: tiansimiao
466 */
467 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, GetStoreSubDirectoryTest001, TestSize.Level0)
468 {
469 /**
470 * @tc.steps: step1. Change Type;
471 * @tc.expected: LOCAL_SUB_DIR.
472 */
473 int type = DistributedDB::KvDBProperties::LOCAL_TYPE_SQLITE;
474 EXPECT_EQ(KvDBProperties::GetStoreSubDirectory(type), DBConstant::LOCAL_SUB_DIR);
475 }
476
477 /**
478 * @tc.name: GetStoreSubDirectoryTest002
479 * @tc.desc: test different type
480 * @tc.type: FUNC
481 * @tc.require:
482 * @tc.author: tiansimiao
483 */
484 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, GetStoreSubDirectoryTest002, TestSize.Level0)
485 {
486 /**
487 * @tc.steps: step1. Change Type;
488 * @tc.expected: MULTI_SUB_DIR.
489 */
490 int type = DistributedDB::KvDBProperties::MULTI_VER_TYPE_SQLITE;
491 EXPECT_EQ(KvDBProperties::GetStoreSubDirectory(type), DBConstant::MULTI_SUB_DIR);
492 }
493
494 /**
495 * @tc.name: GetStoreSubDirectoryTest003
496 * @tc.desc: test different type
497 * @tc.type: FUNC
498 * @tc.require:
499 * @tc.author: tiansimiao
500 */
501 HWTEST_F(DistributedDBStorageSingleVerDatabaseOperTest, GetStoreSubDirectoryTest003, TestSize.Level0)
502 {
503 /**
504 * @tc.steps: step1. Change Type;
505 * @tc.expected: unknown.
506 */
507 int type = 404;
508 EXPECT_EQ(KvDBProperties::GetStoreSubDirectory(type), "unknown");
509 }
510 }