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