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