1 /*
2 * Copyright (c) 2022 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 #define LOG_TAG "BackupManagerTest"
17 #include <condition_variable>
18 #include <gtest/gtest.h>
19 #include <vector>
20
21 #include "dev_manager.h"
22 #include "store_manager.h"
23 #include "store_util.h"
24 #include "sys/stat.h"
25 #include "types.h"
26 using namespace testing::ext;
27 using namespace OHOS::DistributedKv;
28 class BackupManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 Status DeleteBackUpFiles(std::shared_ptr<SingleKvStore> kvStore, std::string baseDir, StoreId storeId);
35 void MkdirPath(std::string baseDir, AppId appId, StoreId storeId);
36
37 std::shared_ptr<SingleKvStore> CreateKVStore(std::string storeIdTest, std::string appIdTest, std::string baseDir,
38 KvStoreType type, bool encrypt);
39 std::shared_ptr<SingleKvStore> kvStore_;
40 };
41
SetUpTestCase(void)42 void BackupManagerTest::SetUpTestCase(void)
43 {
44 std::string baseDir = "/data/service/el1/public/database/BackupManagerTest";
45 mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
46 mkdir((baseDir + "/key").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
47 }
48
TearDownTestCase(void)49 void BackupManagerTest::TearDownTestCase(void)
50 {
51 std::string baseDir = "/data/service/el1/public/database/BackupManagerTest";
52 StoreManager::GetInstance().Delete({ "BackupManagerTest" }, { "SingleKVStore" }, baseDir);
53
54 (void)remove("/data/service/el1/public/database/BackupManagerTest/key");
55 (void)remove("/data/service/el1/public/database/BackupManagerTest/kvdb");
56 (void)remove("/data/service/el1/public/database/BackupManagerTest");
57 }
58
SetUp(void)59 void BackupManagerTest::SetUp(void)
60 {
61 std::string baseDir = "/data/service/el1/public/database/BackupManagerTest";
62 kvStore_ = CreateKVStore("SingleKVStore", "BackupManagerTest", baseDir, SINGLE_VERSION, false);
63 if (kvStore_ == nullptr) {
64 kvStore_ = CreateKVStore("SingleKVStore", "BackupManagerTest", baseDir, SINGLE_VERSION, false);
65 }
66 ASSERT_NE(kvStore_, nullptr);
67 }
68
TearDown(void)69 void BackupManagerTest::TearDown(void)
70 {
71 AppId appId = { "BackupManagerTest" };
72 StoreId storeId = { "SingleKVStore" };
73 std::string baseDir = "/data/service/el1/public/database/BackupManagerTest";
74 auto status = DeleteBackUpFiles(kvStore_, baseDir, storeId);
75 ASSERT_EQ(status, SUCCESS);
76 kvStore_ = nullptr;
77 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
78 ASSERT_EQ(status, SUCCESS);
79 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
80 ASSERT_EQ(status, SUCCESS);
81 }
82
CreateKVStore(std::string storeIdTest,std::string appIdTest,std::string baseDir,KvStoreType type,bool encrypt)83 std::shared_ptr<SingleKvStore> BackupManagerTest::CreateKVStore(std::string storeIdTest, std::string appIdTest,
84 std::string baseDir, KvStoreType type, bool encrypt)
85 {
86 Options options;
87 options.kvStoreType = type;
88 options.securityLevel = S1;
89 options.encrypt = encrypt;
90 options.area = EL1;
91 options.baseDir = baseDir;
92
93 AppId appId = { appIdTest };
94 StoreId storeId = { storeIdTest };
95 Status status = StoreManager::GetInstance().Delete(appId, storeId, options.baseDir);
96 return StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
97 }
DeleteBackUpFiles(std::shared_ptr<SingleKvStore> kvStore,string baseDir,StoreId storeId)98 Status BackupManagerTest::DeleteBackUpFiles(std::shared_ptr<SingleKvStore> kvStore, string baseDir, StoreId storeId)
99 {
100 std::vector<string> backupnames;
101 auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId);
102 for (auto file : files) {
103 auto filename = file.name.substr(0, file.name.length() - 4);
104 backupnames.emplace_back(filename);
105 }
106 if (backupnames.empty()) {
107 return SUCCESS;
108 }
109 std::map<std::string, OHOS::DistributedKv::Status> results;
110 return kvStore->DeleteBackup(backupnames, baseDir, results);
111 }
MkdirPath(std::string baseDir,AppId appId,StoreId storeId)112 void BackupManagerTest::MkdirPath(std::string baseDir, AppId appId, StoreId storeId)
113 {
114 mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
115 mkdir((baseDir + "/key").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
116 mkdir((baseDir + "/kvdb").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
117 mkdir((baseDir + "/kvdb/backup").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
118
119 std::string backUpToPath = { baseDir + "/kvdb/backup/" + storeId.storeId };
120 mkdir(backUpToPath.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
121
122 std::string backUpFile = backUpToPath + "/" + "testbackup.bak";
123 auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(backUpFile);
124 ASSERT_EQ(fl, true);
125 }
126
127 /**
128 * @tc.name: BackUp
129 * @tc.desc: the kvstore back up
130 * @tc.type: FUNC
131 * @tc.require:
132 * @tc.author: Wang Kai
133 */
134 HWTEST_F(BackupManagerTest, BackUp, TestSize.Level0)
135 {
136 ASSERT_NE(kvStore_, nullptr);
137 auto baseDir = "/data/service/el1/public/database/BackupManagerTest";
138 auto status = kvStore_->Backup("testbackup", baseDir);
139 ASSERT_EQ(status, SUCCESS);
140 }
141 /**
142 * @tc.name: BackUpInvalidArguments
143 * @tc.desc: the kvstore back up and the arguments is invalid
144 * @tc.type: FUNC
145 * @tc.require:
146 * @tc.author: Wang Kai
147 */
148 HWTEST_F(BackupManagerTest, BackUpInvalidArguments, TestSize.Level0)
149 {
150 ASSERT_NE(kvStore_, nullptr);
151 auto baseDir = "";
152 auto baseDir1 = "/data/service/el1/public/database/BackupManagerTest";
153 auto status = kvStore_->Backup("testbackup", baseDir);
154 ASSERT_EQ(status, INVALID_ARGUMENT);
155 status = kvStore_->Backup("", baseDir);
156 ASSERT_EQ(status, INVALID_ARGUMENT);
157 status = kvStore_->Backup("autoBackup", baseDir1);
158 ASSERT_EQ(status, INVALID_ARGUMENT);
159 }
160 /**
161 * @tc.name: BackUpSameFile
162 * @tc.desc: the kvstore back up the same file
163 * @tc.type: FUNC
164 * @tc.require:
165 * @tc.author: Wang Kai
166 */
167 HWTEST_F(BackupManagerTest, BackUpSameFile, TestSize.Level0)
168 {
169 ASSERT_NE(kvStore_, nullptr);
170 auto baseDir = "/data/service/el1/public/database/BackupManagerTest";
171 auto status = kvStore_->Backup("testbackup", baseDir);
172 ASSERT_EQ(status, SUCCESS);
173 status = kvStore_->Backup("testbackup", baseDir);
174 ASSERT_EQ(status, SUCCESS);
175 }
176 /**
177 * @tc.name: ReStore
178 * @tc.desc: the kvstore ReStore
179 * @tc.type: FUNC
180 * @tc.require:
181 * @tc.author: Wang Kai
182 */
183 HWTEST_F(BackupManagerTest, ReStore, TestSize.Level0)
184 {
185 ASSERT_NE(kvStore_, nullptr);
186 auto status = kvStore_->Put({ "Put Test" }, { "Put Value" });
187 ASSERT_EQ(status, SUCCESS);
188 Value value;
189 status = kvStore_->Get({ "Put Test" }, value);
190 ASSERT_EQ(status, SUCCESS);
191 ASSERT_EQ(std::string("Put Value"), value.ToString());
192
193 auto baseDir = "/data/service/el1/public/database/BackupManagerTest";
194 auto baseDir1 = "";
195 status = kvStore_->Backup("testbackup", baseDir);
196 ASSERT_EQ(status, SUCCESS);
197 status = kvStore_->Delete("Put Test");
198 ASSERT_EQ(status, SUCCESS);
199 status = kvStore_->Restore("testbackup", baseDir);
200 ASSERT_EQ(status, SUCCESS);
201 value = {};
202 status = kvStore_->Get("Put Test", value);
203 ASSERT_EQ(status, SUCCESS);
204 ASSERT_EQ(std::string("Put Value"), value.ToString());
205 status = kvStore_->Restore("testbackup", baseDir1);
206 ASSERT_EQ(status, INVALID_ARGUMENT);
207 }
208 /**
209 * @tc.name: DeleteBackup
210 * @tc.desc: the kvstore DeleteBackup
211 * @tc.type: FUNC
212 * @tc.require:
213 * @tc.author: Wang Kai
214 */
215 HWTEST_F(BackupManagerTest, DeleteBackup, TestSize.Level0)
216 {
217 ASSERT_NE(kvStore_, nullptr);
218 auto baseDir = "/data/service/el1/public/database/BackupManagerTest";
219 std::string file1 = "testbackup1";
220 std::string file2 = "testbackup2";
221 std::string file3 = "testbackup3";
222 std::string file4 = "autoBackup";
223 kvStore_->Backup(file1, baseDir);
224 kvStore_->Backup(file2, baseDir);
225 kvStore_->Backup(file3, baseDir);
226 vector<std::string> files = { file1, file2, file3, file4 };
227 std::map<std::string, OHOS::DistributedKv::Status> results;
228 auto status = kvStore_->DeleteBackup(files, baseDir, results);
229 ASSERT_EQ(status, SUCCESS);
230 status = kvStore_->DeleteBackup(files, "", results);
231 ASSERT_EQ(status, INVALID_ARGUMENT);
232 }
233 /**
234 * @tc.name: RollbackKey
235 * @tc.desc: rollback the key
236 * @tc.type: FUNC
237 * @tc.require:
238 * @tc.author: Wang Kai
239 */
240 HWTEST_F(BackupManagerTest, RollbackKey, TestSize.Level0)
241 {
242 AppId appId = { "BackupManagerTestRollBackKey" };
243 StoreId storeId = { "SingleKVStoreEncrypt" };
244 std::string baseDir = "/data/service/el1/public/database/" + appId.appId;
245 MkdirPath(baseDir, appId, storeId);
246
247 std::string buildKeyFile = "Prefix_backup_SingleKVStoreEncrypt_testbackup.key";
248 std::string path = { baseDir + "/key/" + buildKeyFile + ".bk" };
249 auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(path);
250 ASSERT_EQ(fl, true);
251
252 std::string autoBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "autoBackup.bak";
253 fl = OHOS::DistributedKv::StoreUtil::CreateFile(autoBackUpFile);
254 ASSERT_EQ(fl, true);
255
256 std::shared_ptr<SingleKvStore> kvStoreEncrypt;
257 kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true);
258 ASSERT_NE(kvStoreEncrypt, nullptr);
259
260 auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId);
261 auto keyfiles = StoreUtil::GetFiles(baseDir + "/key");
262 bool keyFlag = false;
263 for (auto keyfile : keyfiles) {
264 auto keyfilename = keyfile.name;
265 if (keyfilename == buildKeyFile + ".bk") {
266 keyFlag = true;
267 }
268 }
269 ASSERT_EQ(keyFlag, false);
270
271 auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId);
272 ASSERT_EQ(status, SUCCESS);
273 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
274 ASSERT_EQ(status, SUCCESS);
275 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
276 ASSERT_EQ(status, SUCCESS);
277 }
278
279 /**
280 * @tc.name: RollbackData
281 * @tc.desc: rollback the data
282 * @tc.type: FUNC
283 * @tc.require:
284 * @tc.author: Wang Kai
285 */
286 HWTEST_F(BackupManagerTest, RollbackData, TestSize.Level0)
287 {
288 AppId appId = { "BackupManagerTestRollBackData" };
289 StoreId storeId = { "SingleKVStoreEncrypt" };
290 std::string baseDir = "/data/service/el1/public/database/" + appId.appId;
291 MkdirPath(baseDir, appId, storeId);
292
293 std::string buildBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "testbackup.bak.bk";
294 auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(buildBackUpFile);
295 ASSERT_EQ(fl, true);
296
297 std::shared_ptr<SingleKvStore> kvStoreEncrypt;
298 kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true);
299 ASSERT_NE(kvStoreEncrypt, nullptr);
300
301 auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId);
302 bool dataFlag = false;
303 for (auto datafile : files) {
304 auto datafilename = datafile.name;
305 if (datafilename == "testbackup.bak.bk") {
306 dataFlag = true;
307 }
308 }
309 ASSERT_EQ(dataFlag, false);
310
311 auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId);
312 ASSERT_EQ(status, SUCCESS);
313 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
314 ASSERT_EQ(status, SUCCESS);
315 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
316 ASSERT_EQ(status, SUCCESS);
317 }
318
319 /**
320 * @tc.name: Rollback
321 * @tc.desc: rollback the key
322 * @tc.type: FUNC
323 * @tc.require:
324 * @tc.author: Wang Kai
325 */
326 HWTEST_F(BackupManagerTest, Rollback, TestSize.Level0)
327 {
328 AppId appId = { "BackupManagerTestRollBack" };
329 StoreId storeId = { "SingleKVStoreEncrypt" };
330 std::string baseDir = "/data/service/el1/public/database/" + appId.appId;
331 MkdirPath(baseDir, appId, storeId);
332
333 std::string buildKeyFile = "Prefix_backup_SingleKVStoreEncrypt_testbackup.key";
334 std::string path = { baseDir + "/key/" + buildKeyFile + ".bk" };
335 auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(path);
336 ASSERT_EQ(fl, true);
337
338 std::string buildBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "testbackup.bak.bk";
339 fl = OHOS::DistributedKv::StoreUtil::CreateFile(buildBackUpFile);
340 ASSERT_EQ(fl, true);
341
342 std::shared_ptr<SingleKvStore> kvStoreEncrypt;
343 kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true);
344 ASSERT_NE(kvStoreEncrypt, nullptr);
345
346 auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId);
347 auto keyfiles = StoreUtil::GetFiles(baseDir + "/key");
348 bool keyFlag = false;
349 for (auto keyfile : keyfiles) {
350 auto keyfilename = keyfile.name;
351 if (keyfilename == buildKeyFile + ".bk") {
352 keyFlag = true;
353 }
354 }
355 ASSERT_EQ(keyFlag, false);
356
357 bool dataFlag = false;
358 for (auto datafile : files) {
359 auto datafilename = datafile.name;
360 if (datafilename == "testbackup.bak.bk") {
361 dataFlag = true;
362 }
363 }
364 ASSERT_EQ(dataFlag, false);
365
366 auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId);
367 ASSERT_EQ(status, SUCCESS);
368 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
369 ASSERT_EQ(status, SUCCESS);
370 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
371 ASSERT_EQ(status, SUCCESS);
372 }
373
374 /**
375 * @tc.name: CleanTmp
376 * @tc.desc: Clean up temporary data
377 * @tc.type: FUNC
378 * @tc.require:
379 * @tc.author: Wang Kai
380 */
381 HWTEST_F(BackupManagerTest, CleanTmp, TestSize.Level0)
382 {
383 AppId appId = { "BackupManagerTestCleanTmp" };
384 StoreId storeId = { "SingleKVStoreEncrypt" };
385 std::string baseDir = "/data/service/el1/public/database/" + appId.appId;
386 MkdirPath(baseDir, appId, storeId);
387
388 std::string buildKeyFile = "Prefix_backup_SingleKVStoreEncrypt_testbackup.key";
389 std::string path = { baseDir + "/key/" + buildKeyFile };
390 auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(path);
391 ASSERT_EQ(fl, true);
392
393 std::string buildBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "testbackup.bak.bk";
394 fl = OHOS::DistributedKv::StoreUtil::CreateFile(buildBackUpFile);
395 ASSERT_EQ(fl, true);
396
397 std::shared_ptr<SingleKvStore> kvStoreEncrypt;
398 kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true);
399 ASSERT_NE(kvStoreEncrypt, nullptr);
400
401 auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId);
402 auto keyfiles = StoreUtil::GetFiles(baseDir + "/key");
403 bool keyFlag = false;
404 for (auto keyfile : keyfiles) {
405 auto keyfilename = keyfile.name;
406 if (keyfilename == buildKeyFile + ".bk") {
407 keyFlag = true;
408 }
409 }
410 ASSERT_EQ(keyFlag, false);
411
412 bool dataFlag = false;
413 for (auto datafile : files) {
414 auto datafilename = datafile.name;
415 if (datafilename == "testbackup.bak.bk") {
416 dataFlag = true;
417 }
418 }
419 ASSERT_EQ(dataFlag, false);
420
421 auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId);
422 ASSERT_EQ(status, SUCCESS);
423 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
424 ASSERT_EQ(status, SUCCESS);
425 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
426 ASSERT_EQ(status, SUCCESS);
427 }
428
429 /**
430 * @tc.name: BackUpEncrypt
431 * @tc.desc: Back up an encrypt database and restore
432 * @tc.type: FUNC
433 * @tc.require:
434 * @tc.author: Wang Kai
435 */
436 HWTEST_F(BackupManagerTest, BackUpEntry, TestSize.Level0)
437 {
438 AppId appId = { "BackupManagerTest" };
439 StoreId storeId = { "SingleKVStoreEncrypt" };
440 std::string baseDir = "/data/service/el1/public/database/BackupManagerTest";
441
442 auto kvStoreEncrypt = CreateKVStore(storeId.storeId, "BackupManagerTest", baseDir, SINGLE_VERSION, true);
443 if (kvStoreEncrypt == nullptr) {
444 kvStoreEncrypt = CreateKVStore(storeId.storeId, "BackupManagerTest", baseDir, SINGLE_VERSION, true);
445 }
446 ASSERT_NE(kvStoreEncrypt, nullptr);
447
448 auto status = kvStoreEncrypt->Put({ "Put Test" }, { "Put Value" });
449 ASSERT_EQ(status, SUCCESS);
450 Value value;
451 status = kvStoreEncrypt->Get({ "Put Test" }, value);
452 ASSERT_EQ(status, SUCCESS);
453 ASSERT_EQ(std::string("Put Value"), value.ToString());
454
455 status = kvStoreEncrypt->Backup("testbackup", baseDir);
456 ASSERT_EQ(status, SUCCESS);
457 status = kvStoreEncrypt->Delete("Put Test");
458 ASSERT_EQ(status, SUCCESS);
459 status = kvStoreEncrypt->Restore("testbackup", baseDir);
460 ASSERT_EQ(status, SUCCESS);
461 value = {};
462 status = kvStoreEncrypt->Get("Put Test", value);
463 ASSERT_EQ(status, SUCCESS);
464 ASSERT_EQ(std::string("Put Value"), value.ToString());
465
466 status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId);
467 ASSERT_EQ(status, SUCCESS);
468 status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
469 ASSERT_EQ(status, SUCCESS);
470 status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
471 ASSERT_EQ(status, SUCCESS);
472 }