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 
16 #define MLOG_TAG "BackupCloneTest"
17 
18 #include "medialibrary_backup_clone_test.h"
19 
20 #define private public
21 #define protected public
22 #include "backup_database_utils.h"
23 #include "backup_file_utils.h"
24 #include "clone_source.h"
25 #include "media_column.h"
26 #include "media_log.h"
27 #include "media_file_utils.h"
28 #include "backup_restore_service.h"
29 #include "base_restore.h"
30 #include "clone_restore.h"
31 #include "medialibrary_rdb_utils.h"
32 #include "medialibrary_rdbstore.h"
33 #include "medialibrary_unistore_manager.h"
34 #include "medialibrary_unittest_utils.h"
35 #include "burst_key_generator.h"
36 #include "backup_const.h"
37 #undef private
38 #undef protected
39 
40 using namespace std;
41 using namespace OHOS;
42 using namespace testing::ext;
43 using namespace OHOS::NativeRdb;
44 
45 namespace OHOS {
46 namespace Media {
47 enum class TestAlbumType {
48     SOURCE = 0,
49     USER,
50     SHOOTING_MODE_PORTRAIT,
51 };
52 string TEST_BACKUP_PATH = "/data/test/backup/db";
53 string TEST_DB_PATH = "/data/storage/el2/database/rdb/media_library.db";
54 string TEST_BACKUP_DB_PATH = TEST_BACKUP_PATH + TEST_DB_PATH;
55 string TEST_FAKE_FILE_DIR = "/fake/fake/fake.fake";
56 const string TEST_PATH = "/data/test";
57 const string SHOOTING_MODE_PORTRAIT_ALBUM_NAME = "1";
58 const string WHERE_CLAUSE_SHOOTING_MODE = "shooting_mode = '1'";
59 const string WHERE_CLAUSE_TRASHED = "date_trashed > 0";
60 const string WHERE_CLAUSE_IS_FAVORITE = "is_favorite > 0";
61 const string WHERE_CLAUSE_HIDDEN = "hidden > 0";
62 const string WHERE_CLAUSE_EDIT = "edit_time > 0";
63 const string INVALID_STR = "-1";
64 const string EMPTY_STR = "";
65 const string TEST_FILE_PATH_PHOTO = "test_file_path_photo";
66 const string TEST_FILE_PATH_VIDEO = "test_file_path_video";
67 const string TEST_FILE_PATH_AUDIO = "test_file_path_audio";
68 const vector<string> CLEAR_SQLS = {
69     "DELETE FROM " + PhotoColumn::PHOTOS_TABLE,
70     "DELETE FROM " + PhotoAlbumColumns::TABLE + " WHERE " + PhotoAlbumColumns::ALBUM_TYPE + " != " +
71         to_string(PhotoAlbumType::SYSTEM),
72     "DELETE FROM " + PhotoMap::TABLE,
73     "DELETE FROM " + ANALYSIS_ALBUM_TABLE + " WHERE " + PhotoAlbumColumns::ALBUM_SUBTYPE + " != " +
74         to_string(PhotoAlbumSubType::SHOOTING_MODE),
75     "DELETE FROM " + ANALYSIS_PHOTO_MAP_TABLE,
76     "DELETE FROM " + AudioColumn::AUDIOS_TABLE,
77 };
78 const vector<string> WHERE_CLAUSE_LIST_PHOTO = { WHERE_CLAUSE_SHOOTING_MODE, WHERE_CLAUSE_TRASHED,
79     WHERE_CLAUSE_IS_FAVORITE, WHERE_CLAUSE_HIDDEN, WHERE_CLAUSE_EDIT,
80 };
81 const vector<string> WHERE_CLAUSE_LIST_AUDIO = { WHERE_CLAUSE_TRASHED, WHERE_CLAUSE_IS_FAVORITE };
82 const unordered_map<TestAlbumType, pair<string, string>> ALBUM_TABLE_MAP = {
83     { TestAlbumType::SOURCE, { PhotoAlbumColumns::TABLE, PhotoMap::TABLE } },
84     { TestAlbumType::USER, { PhotoAlbumColumns::TABLE, PhotoMap::TABLE } },
85     { TestAlbumType::SHOOTING_MODE_PORTRAIT, { ANALYSIS_ALBUM_TABLE, ANALYSIS_PHOTO_MAP_TABLE } },
86 };
87 const unordered_map<TestAlbumType, pair<PhotoAlbumSubType, string>> ALBUM_CONDITION_MAP = {
88     { TestAlbumType::SOURCE, { PhotoAlbumSubType::SOURCE_GENERIC, "" } },
89     { TestAlbumType::USER, { PhotoAlbumSubType::USER_GENERIC, "" } },
90     { TestAlbumType::SHOOTING_MODE_PORTRAIT, { PhotoAlbumSubType::SHOOTING_MODE, SHOOTING_MODE_PORTRAIT_ALBUM_NAME } },
91 };
92 const int32_t INVALID_COUNT = -1;
93 const int32_t EXPECTED_SOURCE_ALBUM_COUNT = 2;
94 const int32_t EXPECTED_USER_ALBUM_COUNT = 1;
95 const int32_t EXPECTED_SHOOTING_MODE_ALBUM_COUNT = 1;
96 const int32_t EXPECTED_PHOTO_COUNT = 5;
97 const int32_t EXPECTED_PHOTO_MAP_COUNT = 7;
98 const int32_t EXPECTED_ANALYSIS_PHOTO_MAP_COUNT = 1;
99 const int32_t EXPECTED_COUNT_1 = 1;
100 const int32_t EXPECTED_COUNT_0 = 0;
101 const int32_t EXPECTED_ALBUM_TOTAL_COUNT = 4;
102 const int32_t EXPECTED_AUDIO_COUNT = 3;
103 const int32_t INVALID_ERROR_CODE = -1;
104 
105 shared_ptr<MediaLibraryRdbStore> g_rdbStore;
106 unique_ptr<CloneRestore> restoreService = nullptr;
107 
ExecuteSqls(shared_ptr<NativeRdb::RdbStore> store,const vector<string> & sqls)108 void ExecuteSqls(shared_ptr<NativeRdb::RdbStore> store, const vector<string> &sqls)
109 {
110     for (const auto &sql : sqls) {
111         int32_t errCode = store->ExecuteSql(sql);
112         if (errCode == E_OK) {
113             continue;
114         }
115         MEDIA_ERR_LOG("Execute %{public}s failed: %{public}d", sql.c_str(), errCode);
116     }
117 }
118 
ClearData()119 void ClearData()
120 {
121     MEDIA_INFO_LOG("Start clear data");
122     ExecuteSqls(g_rdbStore->GetRaw(), CLEAR_SQLS);
123     MediaLibraryRdbUtils::UpdateAllAlbums(g_rdbStore);
124     MEDIA_INFO_LOG("End clear data");
125 }
126 
ClearCloneSource(CloneSource & cloneSource,const string & dbPath)127 void ClearCloneSource(CloneSource &cloneSource, const string &dbPath)
128 {
129     cloneSource.cloneStorePtr_ = nullptr;
130     NativeRdb::RdbHelper::DeleteRdbStore(dbPath);
131 }
132 
Init(CloneSource & cloneSource,const string & path,const vector<string> & tableList)133 void Init(CloneSource &cloneSource, const string &path, const vector<string> &tableList)
134 {
135     MEDIA_INFO_LOG("Start init clone source database");
136     cloneSource.Init(path, tableList);
137 }
138 
GetResultSet(shared_ptr<NativeRdb::RdbStore> rdbStore,const string & querySql)139 shared_ptr<ResultSet> GetResultSet(shared_ptr<NativeRdb::RdbStore> rdbStore, const string &querySql)
140 {
141     if (rdbStore == nullptr) {
142         MEDIA_ERR_LOG("rdbStore is nullptr");
143         return nullptr;
144     }
145     return rdbStore->QuerySql(querySql);
146 }
147 
QueryInt(shared_ptr<NativeRdb::RdbStore> rdbStore,const string & querySql,const string & columnName,int32_t & result)148 void QueryInt(shared_ptr<NativeRdb::RdbStore> rdbStore, const string &querySql, const string &columnName,
149     int32_t &result)
150 {
151     ASSERT_NE(rdbStore, nullptr);
152     auto resultSet = rdbStore->QuerySql(querySql);
153     ASSERT_NE(resultSet, nullptr);
154     ASSERT_EQ(resultSet->GoToFirstRow(), E_OK);
155     result = GetInt32Val(columnName, resultSet);
156     MEDIA_INFO_LOG("Query %{public}s result: %{public}d", querySql.c_str(), result);
157 }
158 
SetUpTestCase(void)159 void MediaLibraryBackupCloneTest::SetUpTestCase(void)
160 {
161     MEDIA_INFO_LOG("Start Init");
162     MediaLibraryUnitTestUtils::Init();
163     g_rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
164     ASSERT_NE(g_rdbStore, nullptr);
165     MEDIA_INFO_LOG("Start init restoreService");
166     restoreService = make_unique<CloneRestore>();
167     restoreService->mediaLibraryRdb_ = g_rdbStore->GetRaw(); // destination database
168 }
169 
TearDownTestCase(void)170 void MediaLibraryBackupCloneTest::TearDownTestCase(void)
171 {
172     MEDIA_INFO_LOG("TearDownTestCase");
173     ClearData();
174     restoreService->mediaLibraryRdb_ = nullptr;
175 }
176 
SetUp()177 void MediaLibraryBackupCloneTest::SetUp() {}
178 
TearDown(void)179 void MediaLibraryBackupCloneTest::TearDown(void) {}
180 
181 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_check_table_column_status_test_001, TestSize.Level0)
182 {
183     MEDIA_INFO_LOG("Start medialibrary_backup_clone_start_restore_test_001");
184     ClearData();
185     CloneSource cloneSource;
186     vector<string> tableList = { PhotoColumn::PHOTOS_TABLE };
187     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
188     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
189     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_PHOTO);
190     EXPECT_EQ(restoreService->IsReadyForRestore(PhotoColumn::PHOTOS_TABLE), true);
191     ClearCloneSource(cloneSource, TEST_BACKUP_DB_PATH);
192 }
193 
194 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_check_table_column_status_test_002, TestSize.Level0)
195 {
196     MEDIA_INFO_LOG("Start medialibrary_backup_clone_check_table_column_status_test_002");
197     ClearData();
198     CloneSource cloneSource;
199     vector<string> tableList = { PhotoColumn::PHOTOS_TABLE, PhotoAlbumColumns::TABLE, PhotoMap::TABLE,
200         ANALYSIS_ALBUM_TABLE, ANALYSIS_PHOTO_MAP_TABLE };
201     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
202     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
203     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_PHOTO);
204     for (const auto &tableName : tableList) {
205         EXPECT_EQ(restoreService->IsReadyForRestore(tableName), true);
206     }
207     ClearCloneSource(cloneSource, TEST_BACKUP_DB_PATH);
208 }
209 
GetAlbumCountByCondition(shared_ptr<NativeRdb::RdbStore> rdbStore,const string & tableName,PhotoAlbumSubType albumSubType,const string & albumName="")210 int32_t GetAlbumCountByCondition(shared_ptr<NativeRdb::RdbStore> rdbStore, const string &tableName,
211     PhotoAlbumSubType albumSubType, const string &albumName = "")
212 {
213     string querySql = "SELECT " + MEDIA_COLUMN_COUNT_1 + " FROM " + tableName + " WHERE " +
214         "album_subtype = " + to_string(static_cast<int32_t>(albumSubType));
215     querySql += albumName.empty() ? "" : " AND album_name = '" + albumName + "'";
216     int32_t result = INVALID_COUNT;
217     QueryInt(rdbStore, querySql, MEDIA_COLUMN_COUNT_1, result);
218     return result;
219 }
220 
221 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_album_test_002, TestSize.Level0)
222 {
223     MEDIA_INFO_LOG("medialibrary_backup_clone_restore_album_test_002 start");
224     ClearData();
225     CloneSource cloneSource;
226     vector<string> tableList = { PhotoColumn::PHOTOS_TABLE, ANALYSIS_ALBUM_TABLE, ANALYSIS_PHOTO_MAP_TABLE };
227     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
228     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
229     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_PHOTO);
230     restoreService->RestoreAlbum();
231     int32_t shootingModeAlbumCount = GetAlbumCountByCondition(g_rdbStore->GetRaw(), ANALYSIS_ALBUM_TABLE,
232         PhotoAlbumSubType::SHOOTING_MODE, SHOOTING_MODE_PORTRAIT_ALBUM_NAME);
233     EXPECT_EQ(shootingModeAlbumCount, EXPECTED_SHOOTING_MODE_ALBUM_COUNT);
234     ClearCloneSource(cloneSource, TEST_BACKUP_DB_PATH);
235 }
236 
GetCountByWhereClause(const string & tableName,shared_ptr<NativeRdb::RdbStore> rdbStore,const string & whereClause="")237 int32_t GetCountByWhereClause(const string &tableName, shared_ptr<NativeRdb::RdbStore> rdbStore,
238     const string &whereClause = "")
239 {
240     string querySql = "SELECT " + MEDIA_COLUMN_COUNT_1 + " FROM " + tableName;
241     querySql += whereClause.empty() ? "" : " WHERE " + whereClause;
242     int32_t result = INVALID_COUNT;
243     QueryInt(rdbStore, querySql, MEDIA_COLUMN_COUNT_1, result);
244     return result;
245 }
246 
HasZeroSizeFile(const vector<FileInfo> & fileInfos)247 bool HasZeroSizeFile(const vector<FileInfo> &fileInfos)
248 {
249     for (const auto &fileInfo : fileInfos) {
250         if (fileInfo.fileSize <= 0) {
251             return true;
252         }
253     }
254     return false;
255 }
256 
GetInsertValues(vector<FileInfo> & fileInfos,int32_t sourceType)257 vector<NativeRdb::ValuesBucket> GetInsertValues(vector<FileInfo> &fileInfos, int32_t sourceType)
258 {
259     vector<NativeRdb::ValuesBucket> values;
260     for (auto &fileInfo : fileInfos) {
261         fileInfo.cloudPath = BackupFileUtils::GetFullPathByPrefixType(PrefixType::CLOUD, fileInfo.relativePath);
262         if (restoreService->IsSameFileForClone(PhotoColumn::PHOTOS_TABLE, fileInfo)) {
263             MEDIA_INFO_LOG("Has same file, skip");
264             continue;
265         }
266         NativeRdb::ValuesBucket value = restoreService->GetInsertValue(fileInfo, fileInfo.cloudPath, sourceType);
267         fileInfo.isNew = true;
268         values.emplace_back(value);
269     }
270     return values;
271 }
272 
InsertPhoto(vector<FileInfo> & fileInfos)273 void InsertPhoto(vector<FileInfo> &fileInfos)
274 {
275     vector<NativeRdb::ValuesBucket> values = GetInsertValues(fileInfos, SourceType::PHOTOS);
276     int64_t photoRowNum = 0;
277     int32_t errCode = restoreService->BatchInsertWithRetry(PhotoColumn::PHOTOS_TABLE, values, photoRowNum);
278     EXPECT_EQ(errCode, E_OK);
279     restoreService->BatchQueryPhoto(fileInfos);
280     int64_t mapRowNum = 0;
281     restoreService->BatchInsertMap(fileInfos, mapRowNum);
282 }
283 
RestorePhoto()284 void RestorePhoto()
285 {
286     unordered_map<string, string> srcColumnInfoMap = BackupDatabaseUtils::GetColumnInfoMap(restoreService->mediaRdb_,
287         PhotoColumn::PHOTOS_TABLE);
288     unordered_map<string, string> dstColumnInfoMap = BackupDatabaseUtils::GetColumnInfoMap(
289         restoreService->mediaLibraryRdb_, PhotoColumn::PHOTOS_TABLE);
290     if (!restoreService->PrepareCommonColumnInfoMap(PhotoColumn::PHOTOS_TABLE, srcColumnInfoMap, dstColumnInfoMap)) {
291         MEDIA_ERR_LOG("Prepare common column info failed");
292         return;
293     }
294     vector<FileInfo> fileInfos = restoreService->QueryFileInfos(0);
295     InsertPhoto(fileInfos);
296 }
297 
GetMapCountByTable(shared_ptr<NativeRdb::RdbStore> rdbStore,const string & tableName)298 int32_t GetMapCountByTable(shared_ptr<NativeRdb::RdbStore> rdbStore, const string &tableName)
299 {
300     string querySql = "SELECT " + MEDIA_COLUMN_COUNT_1 + " FROM " + tableName;
301     int32_t result = INVALID_COUNT;
302     QueryInt(rdbStore, querySql, MEDIA_COLUMN_COUNT_1, result);
303     return result;
304 }
305 
GetAlbumOrMapTotalCount(shared_ptr<NativeRdb::RdbStore> rdbStore,const unordered_map<TestAlbumType,pair<string,string>> & albumTableMap,bool isAlbum)306 int32_t GetAlbumOrMapTotalCount(shared_ptr<NativeRdb::RdbStore> rdbStore,
307     const unordered_map<TestAlbumType, pair<string, string>> &albumTableMap, bool isAlbum)
308 {
309     int32_t totalCount = 0;
310     for (auto it = albumTableMap.begin(); it != albumTableMap.end(); ++it) {
311         TestAlbumType albumType = it->first;
312         auto tablePair = it->second;
313         string tableName = isAlbum ? tablePair.first : tablePair.second;
314         if (!isAlbum) {
315             totalCount += GetMapCountByTable(rdbStore, tableName);
316             continue;
317         }
318         if (ALBUM_CONDITION_MAP.count(albumType) == 0) {
319             MEDIA_ERR_LOG("Get album condition failed: %{public}d", albumType);
320             continue;
321         }
322         auto conditionPair = ALBUM_CONDITION_MAP.at(albumType);
323         totalCount += GetAlbumCountByCondition(rdbStore, tableName, conditionPair.first, conditionPair.second);
324     }
325     return totalCount;
326 }
327 
328 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_check_table_column_status_test_003, TestSize.Level0)
329 {
330     MEDIA_INFO_LOG("Start medialibrary_backup_clone_check_table_column_status_test_003");
331     ClearData();
332     CloneSource cloneSource;
333     vector<string> tableList = { AudioColumn::AUDIOS_TABLE };
334     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
335     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
336     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_AUDIO);
337     EXPECT_EQ(restoreService->IsReadyForRestore(AudioColumn::AUDIOS_TABLE), true);
338     ClearCloneSource(cloneSource, TEST_BACKUP_DB_PATH);
339 }
340 
341 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_audio_test_001, TestSize.Level0)
342 {
343     MEDIA_INFO_LOG("medialibrary_backup_clone_restore_audio_test_001 start");
344     ClearData();
345     CloneSource cloneSource;
346     vector<string> tableList = { AudioColumn::AUDIOS_TABLE };
347     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
348     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
349     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_AUDIO);
350     vector<FileInfo> fileInfos = restoreService->QueryFileInfos(AudioColumn::AUDIOS_TABLE, 0);
351     int32_t audioCount = static_cast<int32_t>(fileInfos.size());
352     EXPECT_EQ(audioCount, EXPECTED_AUDIO_COUNT);
353     EXPECT_EQ(HasZeroSizeFile(fileInfos), false);
354     ClearCloneSource(cloneSource, TEST_BACKUP_DB_PATH);
355 }
356 
PrepareFileInfos(const string & tableName,vector<FileInfo> & fileInfos)357 void PrepareFileInfos(const string &tableName, vector<FileInfo> &fileInfos)
358 {
359     for (auto &fileInfo : fileInfos) {
360         fileInfo.cloudPath = BackupFileUtils::GetFullPathByPrefixType(PrefixType::CLOUD, fileInfo.relativePath);
361         fileInfo.isNew = !restoreService->HasSameAudioFile(restoreService->mediaLibraryRdb_, tableName, fileInfo);
362     }
363 }
364 
365 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_audio_test_002, TestSize.Level0)
366 {
367     MEDIA_INFO_LOG("medialibrary_backup_clone_restore_audio_test_002 start");
368     int32_t count = 3;
369     ClearData();
370     CloneSource cloneSource;
371     vector<string> tableList = { AudioColumn::AUDIOS_TABLE };
372     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
373     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
374     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_AUDIO);
375     EXPECT_EQ(count, EXPECTED_AUDIO_COUNT);
376     // need judge file count later
377 }
378 
379 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_audio_test_003, TestSize.Level0)
380 {
381     MEDIA_INFO_LOG("medialibrary_backup_clone_restore_audio_test_003 start");
382     int32_t audioCountBefore = GetCountByWhereClause(AudioColumn::AUDIOS_TABLE, g_rdbStore->GetRaw());
383     int32_t count = 3;
384     CloneSource cloneSource;
385     vector<string> tableList = { AudioColumn::AUDIOS_TABLE };
386     Init(cloneSource, TEST_BACKUP_DB_PATH, tableList);
387     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_; // source database
388     restoreService->CheckTableColumnStatus(restoreService->mediaRdb_, CLONE_TABLE_LISTS_AUDIO);
389     EXPECT_EQ(count, EXPECTED_AUDIO_COUNT);
390     // need judge file count later
391 }
392 
393 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_is_file_valid_test_001, TestSize.Level0)
394 {
395     MEDIA_INFO_LOG("medialibrary_backup_clone_is_file_valid_test_001 start");
396     EXPECT_EQ(BackupFileUtils::IsFileValid(TEST_DB_PATH, CLONE_RESTORE_ID), E_OK);
397     EXPECT_EQ(BackupFileUtils::IsFileValid(TEST_BACKUP_PATH, CLONE_RESTORE_ID), E_FAIL); // directory
398     EXPECT_EQ(BackupFileUtils::IsFileValid(TEST_FAKE_FILE_DIR, CLONE_RESTORE_ID), E_NO_SUCH_FILE); // not exist
399 }
400 
ClearRestoreExInfo()401 void ClearRestoreExInfo()
402 {
403     restoreService->errorCode_ = RestoreError::SUCCESS;
404     restoreService->errorInfo_.clear();
405     restoreService->failedFilesMap_.clear();
406 }
407 
408 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_service_start_restore_ex_001, TestSize.Level0)
409 {
410     MEDIA_INFO_LOG("medialibrary_backup_service_start_restore_ex_001 start");
411     RestoreInfo info;
412     info.sceneCode = UPGRADE_RESTORE_ID;
413     info.galleryAppName = EMPTY_STR;
414     info.mediaAppName = EMPTY_STR;
415     info.backupDir = EMPTY_STR;
416     info.bundleInfo = EMPTY_STR;
417     string restoreExInfo = INVALID_STR;
418     BackupRestoreService::GetInstance().StartRestoreEx(nullptr, info, restoreExInfo);
419     MEDIA_INFO_LOG("Get restoreExInfo: %{public}s", restoreExInfo.c_str());
420     EXPECT_NE(restoreExInfo, EMPTY_STR); // upgrade is now supported
421 }
422 
423 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_service_start_restore_ex_002, TestSize.Level0)
424 {
425     MEDIA_INFO_LOG("medialibrary_backup_service_start_restore_ex_002 start");
426     RestoreInfo info;
427     info.sceneCode = DUAL_FRAME_CLONE_RESTORE_ID;
428     info.galleryAppName = EMPTY_STR;
429     info.mediaAppName = EMPTY_STR;
430     info.backupDir = EMPTY_STR;
431     info.bundleInfo = EMPTY_STR;
432     string restoreExInfo = INVALID_STR;
433     BackupRestoreService::GetInstance().StartRestoreEx(nullptr, info, restoreExInfo);
434     MEDIA_INFO_LOG("Get restoreExInfo: %{public}s", restoreExInfo.c_str());
435     EXPECT_NE(restoreExInfo, EMPTY_STR); // dual clone is now supported
436 }
437 
438 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_service_start_restore_ex_003, TestSize.Level0)
439 {
440     MEDIA_INFO_LOG("medialibrary_backup_service_start_restore_ex_003 start");
441     RestoreInfo info;
442     info.sceneCode = CLONE_RESTORE_ID;
443     info.galleryAppName = EMPTY_STR;
444     info.mediaAppName = EMPTY_STR;
445     info.backupDir = EMPTY_STR;
446     info.bundleInfo = EMPTY_STR;
447     string restoreExInfo = INVALID_STR;
448     BackupRestoreService::GetInstance().StartRestoreEx(nullptr, info, restoreExInfo);
449     MEDIA_INFO_LOG("Get restoreExInfo: %{public}s", restoreExInfo.c_str());
450     EXPECT_NE(restoreExInfo, EMPTY_STR); // single clone is now supported
451 }
452 
453 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_service_get_backup_info_001, TestSize.Level0)
454 {
455     MEDIA_INFO_LOG("medialibrary_backup_service_get_backup_info_001 start");
456     string backupInfo = INVALID_STR;
457     BackupRestoreService::GetInstance().GetBackupInfo(UPGRADE_RESTORE_ID, backupInfo);
458     MEDIA_INFO_LOG("Get backupInfo: %{public}s", backupInfo.c_str());
459     EXPECT_EQ(backupInfo, EMPTY_STR); // upgrade is not supported
460 }
461 
462 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_base_get_restore_ex_info_001, TestSize.Level0)
463 {
464     MEDIA_INFO_LOG("medialibrary_backup_base_get_restore_ex_info_001 start");
465     ClearRestoreExInfo();
466     string restoreExInfo = restoreService->GetRestoreExInfo();
467     MEDIA_INFO_LOG("Get restoreExInfo: %{public}s", restoreExInfo.c_str());
468     EXPECT_GT(restoreExInfo.size(), 0);
469     nlohmann::json jsonObject = nlohmann::json::parse(restoreExInfo);
470     EXPECT_EQ(jsonObject.empty(), false);
471     EXPECT_EQ(jsonObject.is_discarded(), false);
472 }
473 
474 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_base_set_error_code_001, TestSize.Level0)
475 {
476     MEDIA_INFO_LOG("medialibrary_backup_base_set_error_code_001 start");
477     ClearRestoreExInfo();
478     restoreService->SetErrorCode(RestoreError::INIT_FAILED);
479     MEDIA_INFO_LOG("Get errorCode: %{public}d, errorInfo: %{public}s", restoreService->errorCode_,
480         restoreService->errorInfo_.c_str());
481     EXPECT_GT(restoreService->errorInfo_.size(), 0);
482 }
483 
484 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_base_set_error_code_002, TestSize.Level0)
485 {
486     MEDIA_INFO_LOG("medialibrary_backup_base_set_error_code_002 start");
487     ClearRestoreExInfo();
488     restoreService->SetErrorCode(INVALID_ERROR_CODE);
489     MEDIA_INFO_LOG("Get errorCode: %{public}d, errorInfo: %{public}s", restoreService->errorCode_,
490         restoreService->errorInfo_.c_str());
491     EXPECT_EQ(restoreService->errorInfo_.size(), 0);
492 }
493 
494 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_base_update_failed_files_001, TestSize.Level0)
495 {
496     MEDIA_INFO_LOG("medialibrary_backup_base_update_failed_files_001 start");
497     ClearRestoreExInfo();
498     FileInfo fileInfo;
499     fileInfo.oldPath = TEST_FILE_PATH_PHOTO;
500     restoreService->UpdateFailedFiles(static_cast<int32_t>(MediaType::MEDIA_TYPE_IMAGE), fileInfo,
501         RestoreError::FILE_INVALID);
502     fileInfo.oldPath = TEST_FILE_PATH_VIDEO;
503     restoreService->UpdateFailedFiles(static_cast<int32_t>(MediaType::MEDIA_TYPE_VIDEO), fileInfo,
504         RestoreError::MOVE_FAILED);
505     fileInfo.oldPath = TEST_FILE_PATH_AUDIO;
506     restoreService->UpdateFailedFiles(static_cast<int32_t>(MediaType::MEDIA_TYPE_AUDIO), fileInfo,
507         RestoreError::PATH_INVALID);
508     MEDIA_INFO_LOG("Get failedFilesMap size: %{public}zu", restoreService->failedFilesMap_.size());
509     EXPECT_GT(restoreService->failedFilesMap_.size(), 0);
510     EXPECT_GT(restoreService->failedFilesMap_.count(STAT_TYPE_PHOTO), 0);
511     EXPECT_GT(restoreService->failedFilesMap_.count(STAT_TYPE_VIDEO), 0);
512     EXPECT_GT(restoreService->failedFilesMap_.count(STAT_TYPE_AUDIO), 0);
513 }
514 
515 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_get_backup_info_001, TestSize.Level0)
516 {
517     MEDIA_INFO_LOG("medialibrary_backup_base_get_backup_info_001 start");
518     string backupInfo = restoreService->GetBackupInfo();
519     MEDIA_INFO_LOG("Get backupInfo: %{public}s", backupInfo.c_str());
520     EXPECT_GT(backupInfo.size(), 0);
521     nlohmann::json jsonObject = nlohmann::json::parse(backupInfo);
522     EXPECT_EQ(jsonObject.empty(), false);
523     EXPECT_EQ(jsonObject.is_discarded(), false);
524 }
525 
526 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_file_get_failed_files_str_001, TestSize.Level0)
527 {
528     MEDIA_INFO_LOG("medialibrary_backup_file_get_failed_files_str_001 start");
529     FileInfo fileInfo;
530     unordered_map<string, FailedFileInfo> failedFiles = {
531         { TEST_FILE_PATH_PHOTO, FailedFileInfo(CLONE_RESTORE_ID, fileInfo, RestoreError::FILE_INVALID) },
532         { TEST_FILE_PATH_VIDEO, FailedFileInfo(CLONE_RESTORE_ID, fileInfo, RestoreError::MOVE_FAILED) },
533         { TEST_FILE_PATH_AUDIO, FailedFileInfo(CLONE_RESTORE_ID, fileInfo, RestoreError::PATH_INVALID) },
534     };
535     string failedFilesStr = BackupFileUtils::GetFailedFilesStr(CLONE_RESTORE_ID, failedFiles, MAX_FAILED_FILES_LIMIT);
536     MEDIA_INFO_LOG("Get failedFilesStr: %{public}s", failedFilesStr.c_str());
537     EXPECT_GT(failedFilesStr.size(), 0);
538 }
539 
540 /**
541  * @brief BurstKeyGenerator should give the same uuid for diffirent FileInfo in one Bucket
542  */
543 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_file_burst_key_generator_001, TestSize.Level0)
544 {
545     MEDIA_INFO_LOG("medialibrary_backup_file_burst_key_generator_001 start");
546     BurstKeyGenerator burstKeyGenerator;
547     std::vector<FileInfo> fileInfos;
548     std::vector<std::string> hashs = {
549         "374c3cacde794191acd933529e860997",
550         "fe02dx0ea6115ce236151a1a11d144c8",
551         "3e3a7bf47a15aec4ac10f4fa08dc8b99",
552         "d18a6a01bd430b2bb91d8f3d0a9b4bee",
553         "1cdde93b419c574ef39e5893179743c5"
554     };
555     for (int i = 0; i < 5; i++) {
556         FileInfo item;
557         item.title = "IMG_20240619_022412_BURST00" + std::to_string(i);
558         item.relativeBucketId = "2064266562";
559         item.recycleFlag = 0;
560         item.isBurst = 2;
561         item.hashCode = hashs[i];
562         fileInfos.push_back(item);
563     }
564     fileInfos[0].isBurst = 1;
565     string burstKey;
566     for (int i = 0; i < fileInfos.size(); i++) {
567         if (burstKey.empty()) {
568             burstKey = burstKeyGenerator.FindBurstKey(fileInfos[i]);
569         }
570         else {
571             EXPECT_EQ(burstKey, burstKeyGenerator.FindBurstKey(fileInfos[i]));
572         }
573     }
574     MEDIA_INFO_LOG("medialibrary_backup_file_burst_key_generator_001 end");
575 }
576 
577 /**
578  * @brief BurstKeyGenerator should give the different uuid for same FileInfo in Recycle Bin
579  */
580 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_file_burst_key_generator_002, TestSize.Level0)
581 {
582     MEDIA_INFO_LOG("medialibrary_backup_file_burst_key_generator_002 start");
583     BurstKeyGenerator burstKeyGenerator;
584     std::vector<FileInfo> fileInfos;
585     for (int i = 0; i < 5; i++) {
586         FileInfo item;
587         item.title = "IMG_20240619_022412_BURST001";
588         item.relativeBucketId = "2064266562";
589         item.recycleFlag = 2;
590         item.isBurst = 2;
591         item.hashCode = "374c3cacde794191acd933529e860997";
592         fileInfos.push_back(item);
593     }
594     string burstKey;
595     for (int i = 0; i < fileInfos.size(); i++) {
596         if (burstKey.empty()) {
597             burstKey = burstKeyGenerator.FindBurstKey(fileInfos[i]);
598         }
599         else {
600             EXPECT_NE(burstKey, burstKeyGenerator.FindBurstKey(fileInfos[i]));
601         }
602     }
603     MEDIA_INFO_LOG("medialibrary_backup_file_burst_key_generator_002 end");
604 }
605 
606 /**
607  * @brief BurstKeyGenerator should give the different uuid for same FileInfo in different Bucket
608  */
609 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_file_burst_key_generator_003, TestSize.Level0)
610 {
611     MEDIA_INFO_LOG("medialibrary_backup_file_burst_key_generator_003 start");
612     BurstKeyGenerator burstKeyGenerator;
613     std::vector<FileInfo> fileInfos;
614     for (int i = 0; i < 5; i++) {
615         FileInfo item;
616         item.title = "IMG_20240619_022412_BURST001";
617         item.relativeBucketId = "2064266562" + std::to_string(i);
618         item.recycleFlag = 0;
619         item.isBurst = 2;
620         item.hashCode = "374c3cacde794191acd933529e860997";
621         fileInfos.push_back(item);
622     }
623     string burstKey;
624     for (int i = 0; i < fileInfos.size(); i++) {
625         if (burstKey.empty()) {
626             burstKey = burstKeyGenerator.FindBurstKey(fileInfos[i]);
627         }
628         else {
629             EXPECT_NE(burstKey, burstKeyGenerator.FindBurstKey(fileInfos[i]));
630         }
631     }
632     MEDIA_INFO_LOG("medialibrary_backup_file_burst_key_generator_003 end");
633 }
634 
635 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_portrait_album_test_001, TestSize.Level0)
636 {
637     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_portrait_album_test_001");
638 
639     ClearData();
640     CloneSource cloneSource;
641     vector<string> tableList = { ANALYSIS_ALBUM_TABLE };
642     Init(cloneSource, TEST_DB_PATH, tableList);
643 
644     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_;
645     restoreService->mediaLibraryRdb_ = g_rdbStore->GetRaw();
646     restoreService->RestoreFromGalleryPortraitAlbum();
647 
648     VerifyPortraitAlbumRestore(restoreService->mediaLibraryRdb_);
649 }
650 
VerifyPortraitAlbumRestore(const std::shared_ptr<NativeRdb::RdbStore> & db)651 void MediaLibraryBackupCloneTest::VerifyPortraitAlbumRestore(const std::shared_ptr<NativeRdb::RdbStore>& db)
652 {
653     std::string querySql = "SELECT * FROM " + ANALYSIS_ALBUM_TABLE +
654         " WHERE album_type = " + std::to_string(SMART) +
655         " AND album_subtype = " + std::to_string(PORTRAIT);
656 
657     std::shared_ptr<NativeRdb::ResultSet> resultSet = db->QuerySql(querySql);
658     ASSERT_NE(resultSet, nullptr);
659 
660     EXPECT_TRUE(resultSet->GoToFirstRow() == NativeRdb::E_OK);
661 
662     int index;
663     std::string columnValue;
664 
665     (void)resultSet->GetColumnIndex("album_name", index);
666     resultSet->GetString(index, columnValue);
667     EXPECT_EQ(columnValue, "Test Portrait Album");
668 
669     (void)resultSet->GetColumnIndex("tag_id", index);
670     resultSet->GetString(index, columnValue);
671     EXPECT_EQ(columnValue, "test_tag_id");
672 
673     (void)resultSet->GetColumnIndex("cover_uri", index);
674     resultSet->GetString(index, columnValue);
675     EXPECT_EQ(columnValue, "test_cover_uri");
676 
677     (void)resultSet->GetColumnIndex("is_cover_satisfied", index);
678     int isCoverSatisfied;
679     resultSet->GetInt(index, isCoverSatisfied);
680     EXPECT_EQ(isCoverSatisfied, 1);
681 
682     EXPECT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
683 }
684 
685 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_portrait_clustering_test_001, TestSize.Level0)
686 {
687     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_portrait_clustering_test_001");
688 
689     ClearData();
690     CloneSource cloneSource;
691     vector<string> tableList = { VISION_FACE_TAG_TABLE };
692     Init(cloneSource, TEST_DB_PATH, tableList);
693 
694     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_;
695     restoreService->mediaLibraryRdb_ = g_rdbStore->GetRaw();
696     restoreService->RestorePortraitClusteringInfo();
697 
698     VerifyPortraitClusteringRestore(restoreService->mediaLibraryRdb_);
699 }
700 
VerifyPortraitClusteringRestore(const std::shared_ptr<NativeRdb::RdbStore> & db)701 void MediaLibraryBackupCloneTest::VerifyPortraitClusteringRestore(const std::shared_ptr<NativeRdb::RdbStore>& db)
702 {
703     std::string querySql = "SELECT * FROM " + VISION_FACE_TAG_TABLE;
704 
705     std::shared_ptr<NativeRdb::ResultSet> resultSet = db->QuerySql(querySql);
706     ASSERT_NE(resultSet, nullptr);
707 
708     EXPECT_TRUE(resultSet->GoToFirstRow() == NativeRdb::E_OK);
709 
710     int index;
711     std::string stringValue;
712     int intValue;
713 
714     (void)resultSet->GetColumnIndex(FACE_TAG_COL_TAG_ID, index);
715     resultSet->GetString(index, stringValue);
716     EXPECT_EQ(stringValue, "test_tag_id");
717 
718     (void)resultSet->GetColumnIndex(FACE_TAG_COL_TAG_NAME, index);
719     resultSet->GetString(index, stringValue);
720     EXPECT_EQ(stringValue, "Test Face Tag");
721 
722     (void)resultSet->GetColumnIndex(FACE_TAG_COL_CENTER_FEATURES, index);
723     resultSet->GetString(index, stringValue);
724     EXPECT_EQ(stringValue, "test_center_features");
725 
726     (void)resultSet->GetColumnIndex(FACE_TAG_COL_TAG_VERSION, index);
727     resultSet->GetInt(index, intValue);
728     EXPECT_EQ(intValue, 1);
729 
730     (void)resultSet->GetColumnIndex(FACE_TAG_COL_ANALYSIS_VERSION, index);
731     resultSet->GetInt(index, intValue);
732     EXPECT_EQ(intValue, 1);
733     EXPECT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
734 }
735 
736 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_image_face_test_001, TestSize.Level0)
737 {
738     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_image_face_test_001");
739 
740     ClearData();
741     CloneSource cloneSource;
742     vector<string> tableList = { VISION_IMAGE_FACE_TABLE };
743     Init(cloneSource, TEST_DB_PATH, tableList);
744 
745     std::vector<FileInfo> fileInfos;
746     SetupMockImgFaceData(fileInfos);
747 
748     restoreService->mediaRdb_ = cloneSource.cloneStorePtr_;
749     restoreService->mediaLibraryRdb_ = g_rdbStore->GetRaw();
750     restoreService->RestoreImageFaceInfo(fileInfos);
751 
752     VerifyImageFaceRestore(restoreService->mediaLibraryRdb_, fileInfos);
753 
754     ClearCloneSource(cloneSource, TEST_DB_PATH);
755 }
756 
SetupMockImgFaceData(std::vector<FileInfo> & fileInfos)757 void MediaLibraryBackupCloneTest::SetupMockImgFaceData(std::vector<FileInfo>& fileInfos)
758 {
759     FileInfo fileInfo;
760     fileInfo.fileIdOld = 1;
761     fileInfo.fileIdNew = FILE_INFO_NEW_ID;
762     fileInfos.push_back(fileInfo);
763 }
764 
VerifyImageFaceRestore(const std::shared_ptr<NativeRdb::RdbStore> & db,const std::vector<FileInfo> & fileInfos)765 void MediaLibraryBackupCloneTest::VerifyImageFaceRestore(const std::shared_ptr<NativeRdb::RdbStore>& db,
766     const std::vector<FileInfo>& fileInfos)
767 {
768     std::string querySql = "SELECT * FROM " + VISION_IMAGE_FACE_TABLE +
769         " WHERE " + IMAGE_FACE_COL_FILE_ID + " = " + std::to_string(fileInfos[0].fileIdNew);
770 
771     std::shared_ptr<NativeRdb::ResultSet> resultSet = db->QuerySql(querySql);
772     ASSERT_NE(resultSet, nullptr);
773 
774     EXPECT_TRUE(resultSet->GoToFirstRow() == NativeRdb::E_OK);
775 
776     int index;
777     int intValue;
778     std::string stringValue;
779     double doubleValue;
780 
781     (void)resultSet->GetColumnIndex(IMAGE_FACE_COL_FILE_ID, index);
782     resultSet->GetInt(index, intValue);
783     EXPECT_EQ(intValue, fileInfos[0].fileIdNew);
784 
785     (void)resultSet->GetColumnIndex(IMAGE_FACE_COL_FACE_ID, index);
786     resultSet->GetString(index, stringValue);
787     EXPECT_EQ(stringValue, "test_face_id");
788 
789     (void)resultSet->GetColumnIndex(IMAGE_FACE_COL_TAG_ID, index);
790     resultSet->GetString(index, stringValue);
791     EXPECT_EQ(stringValue, "test_tag_id");
792 
793     (void)resultSet->GetColumnIndex(IMAGE_FACE_COL_SCALE_X, index);
794     resultSet->GetDouble(index, doubleValue);
795     EXPECT_DOUBLE_EQ(doubleValue, 1.0);
796 
797     (void)resultSet->GetColumnIndex(IMAGE_FACE_COL_SCALE_Y, index);
798     resultSet->GetDouble(index, doubleValue);
799     EXPECT_DOUBLE_EQ(doubleValue, 1.0);
800     EXPECT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
801 }
802 
803 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_service_start_backup_001, TestSize.Level0)
804 {
805     MEDIA_INFO_LOG("Start medialibrary_backup_service_start_backup_001");
806 
807     BackupRestoreService &instance = BackupRestoreService::GetInstance();
808     ASSERT_NE(&instance, nullptr);
809     instance.StartBackup(UPGRADE_RESTORE_ID, EMPTY_STR, EMPTY_STR);
810     instance.StartBackup(CLONE_RESTORE_ID, EMPTY_STR, EMPTY_STR);
811 }
812 
813 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_move_thumbnail_test_001, TestSize.Level0)
814 {
815     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_move_thumbnail_test_001");
816     restoreService->hasCloneThumbnailDir_ = false;
817     FileInfo testFileInfo;
818     int32_t ret = restoreService->MoveThumbnail(testFileInfo);
819     EXPECT_EQ(ret, E_NO_SUCH_FILE);
820 
821     restoreService->hasCloneThumbnailDir_ = true;
822     testFileInfo.thumbnailReady = 0;
823     testFileInfo.lcdVisitTime = 0;
824     ret = restoreService->MoveThumbnail(testFileInfo);
825     EXPECT_EQ(ret, E_NO_SUCH_FILE);
826 
827     restoreService->hasCloneThumbnailDir_ = true;
828     testFileInfo.thumbnailReady = 4;
829     testFileInfo.lcdVisitTime = 0;
830     testFileInfo.relativePath = "";
831     ret = restoreService->MoveThumbnail(testFileInfo);
832     EXPECT_EQ(ret, E_FAIL);
833 
834     restoreService->hasCloneThumbnailDir_ = true;
835     testFileInfo.thumbnailReady = 0;
836     testFileInfo.lcdVisitTime = 2;
837     testFileInfo.relativePath = "";
838     ret = restoreService->MoveThumbnail(testFileInfo);
839     EXPECT_EQ(ret, E_FAIL);
840 }
841 
842 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_move_thumbnail_dir_test_001, TestSize.Level0)
843 {
844     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_move_thumbnail_dir_test_001");
845     FileInfo testFileInfo;
846     testFileInfo.relativePath = "";
847     int32_t ret = restoreService->MoveThumbnailDir(testFileInfo);
848     EXPECT_EQ(ret, E_FAIL);
849 
850     testFileInfo.relativePath = "testPath";
851     testFileInfo.cloudPath = "";
852     ret = restoreService->MoveThumbnailDir(testFileInfo);
853     EXPECT_EQ(ret, E_FAIL);
854 
855     testFileInfo.relativePath = "testPath";
856     testFileInfo.cloudPath = "/storage/cloud/files/test";
857     ret = restoreService->MoveThumbnailDir(testFileInfo);
858     EXPECT_EQ(ret, E_FAIL);
859 }
860 
861 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_move_astc_test_001, TestSize.Level0)
862 {
863     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_move_astc_test_001");
864     FileInfo testFileInfo;
865     restoreService->oldMonthKvStorePtr_ = nullptr;
866     int32_t ret = restoreService->MoveAstc(testFileInfo);
867     EXPECT_EQ(ret, E_FAIL);
868 
869     restoreService->oldMonthKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
870     restoreService->oldYearKvStorePtr_ = nullptr;
871     ret = restoreService->MoveAstc(testFileInfo);
872     EXPECT_EQ(ret, E_FAIL);
873 
874     restoreService->oldYearKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
875     restoreService->newMonthKvStorePtr_ = nullptr;
876     ret = restoreService->MoveAstc(testFileInfo);
877     EXPECT_EQ(ret, E_FAIL);
878 
879     restoreService->newMonthKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
880     restoreService->newYearKvStorePtr_ = nullptr;
881     ret = restoreService->MoveAstc(testFileInfo);
882     EXPECT_EQ(ret, E_FAIL);
883 }
884 
885 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_move_astc_test_002, TestSize.Level0)
886 {
887     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_move_astc_test_002");
888     FileInfo testFileInfo;
889     restoreService->oldMonthKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
890     restoreService->oldYearKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
891     restoreService->newMonthKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
892     restoreService->newYearKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
893 
894     testFileInfo.fileIdOld = -1;
895     int32_t ret = restoreService->MoveAstc(testFileInfo);
896     EXPECT_EQ(ret, E_FAIL);
897 
898     testFileInfo.fileIdOld = 1;
899     testFileInfo.fileIdNew = -1;
900     ret = restoreService->MoveAstc(testFileInfo);
901     EXPECT_EQ(ret, E_FAIL);
902 
903     testFileInfo.fileIdOld = 1;
904     testFileInfo.fileIdNew = 1;
905     testFileInfo.oldAstcDateKey = "";
906     ret = restoreService->MoveAstc(testFileInfo);
907     EXPECT_EQ(ret, E_FAIL);
908 
909     testFileInfo.oldAstcDateKey = "0000000000000a";
910     ret = restoreService->MoveAstc(testFileInfo);
911     EXPECT_EQ(ret, E_FAIL);
912 
913     testFileInfo.oldAstcDateKey = "0000000000000";
914     testFileInfo.newAstcDateKey = "";
915     ret = restoreService->MoveAstc(testFileInfo);
916     EXPECT_EQ(ret, E_FAIL);
917 
918     testFileInfo.oldAstcDateKey = "0";
919     testFileInfo.newAstcDateKey = "0000000000000a";
920     ret = restoreService->MoveAstc(testFileInfo);
921     EXPECT_EQ(ret, E_FAIL);
922 }
923 
924 HWTEST_F(MediaLibraryBackupCloneTest, medialibrary_backup_clone_restore_move_astc_test_003, TestSize.Level0)
925 {
926     MEDIA_INFO_LOG("Start medialibrary_backup_clone_restore_move_astc_test_003");
927     FileInfo testFileInfo;
928     std::string testStoreId = "medialibrary_backup_clone_restore_move_astc_test_003";
929     std::vector<uint8_t> testValue;
930     testValue.assign(testStoreId.begin(), testStoreId.end());
931     restoreService->oldMonthKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
932     restoreService->oldYearKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
933     restoreService->newMonthKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
934     restoreService->newYearKvStorePtr_ = std::make_shared<MediaLibraryKvStore>();
935     int32_t testFileId = 1;
936     std::string testAstcDateKey = "1";
937     testFileInfo.fileIdOld = testFileId;
938     testFileInfo.oldAstcDateKey = testAstcDateKey;
939     testFileInfo.fileIdNew = testFileId;
940     testFileInfo.newAstcDateKey = testAstcDateKey;
941     testFileInfo.isRelatedToPhotoMap = 1;
942     std::string testAstckey;
943     EXPECT_EQ(MediaFileUtils::GenerateKvStoreKey(to_string(testFileId), testAstcDateKey, testAstckey), true);
944     EXPECT_EQ(restoreService->MoveAstc(testFileInfo), E_FAIL);
945 
946     restoreService->oldMonthKvStorePtr_ = MediaLibraryKvStoreManager::GetInstance()
947         .GetSingleKvStore(KvStoreRoleType::OWNER, testStoreId + "old_month", TEST_PATH);
948     if (restoreService->oldMonthKvStorePtr_ == nullptr) {
949         return;
950     }
951     EXPECT_EQ(restoreService->oldMonthKvStorePtr_->Insert(testAstckey, testValue), E_OK);
952     EXPECT_EQ(restoreService->MoveAstc(testFileInfo), E_FAIL);
953 
954     restoreService->newMonthKvStorePtr_ = MediaLibraryKvStoreManager::GetInstance()
955         .GetSingleKvStore(KvStoreRoleType::OWNER, testStoreId + "new_month", TEST_PATH);
956     ASSERT_NE(restoreService->newMonthKvStorePtr_, nullptr);
957     EXPECT_EQ(restoreService->MoveAstc(testFileInfo), E_FAIL);
958 
959     restoreService->oldYearKvStorePtr_ = MediaLibraryKvStoreManager::GetInstance()
960         .GetSingleKvStore(KvStoreRoleType::OWNER, testStoreId + "old_year", TEST_PATH);
961     ASSERT_NE(restoreService->oldYearKvStorePtr_, nullptr);
962     EXPECT_EQ(restoreService->oldYearKvStorePtr_->Insert(testAstckey, testValue), E_OK);
963     EXPECT_EQ(restoreService->MoveAstc(testFileInfo), E_FAIL);
964 
965     restoreService->newYearKvStorePtr_ = MediaLibraryKvStoreManager::GetInstance()
966         .GetSingleKvStore(KvStoreRoleType::OWNER, testStoreId + "new_year", TEST_PATH);
967     ASSERT_NE(restoreService->newYearKvStorePtr_, nullptr);
968     EXPECT_EQ(restoreService->MoveAstc(testFileInfo), E_OK);
969 
970     testFileInfo.isRelatedToPhotoMap = 0;
971     EXPECT_EQ(restoreService->MoveAstc(testFileInfo), E_OK);
972     MEDIA_INFO_LOG("End medialibrary_backup_clone_restore_move_astc_test_003");
973 }
974 } // namespace Media
975 } // namespace OHOS