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