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 #include "medialibrary_unittest_utils.h"
17
18 #include <fstream>
19
20 #include "ability_context_impl.h"
21 #include "fetch_result.h"
22 #include "media_log.h"
23 #include "medialibrary_data_manager.h"
24 #include "mimetype_utils.h"
25 #include "result_set_utils.h"
26 #include "scanner_utils.h"
27
28 using namespace std;
29 using namespace OHOS::DataShare;
30 using namespace OHOS::AppExecFwk;
31 namespace OHOS {
32 namespace Media {
IsValid()33 bool MediaLibraryUnitTestUtils::IsValid()
34 {
35 return isValid_;
36 }
37
Init()38 void MediaLibraryUnitTestUtils::Init()
39 {
40 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
41 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
42 abilityContextImpl->SetStageContext(stageContext);
43 MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl, abilityContextImpl);
44 auto ret = MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl, abilityContextImpl);
45 CHECK_AND_RETURN_LOG(ret == E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
46 isValid_ = true;
47 }
48
InitRootDirs()49 void MediaLibraryUnitTestUtils::InitRootDirs()
50 {
51 for (const auto &dir : TEST_ROOT_DIRS) {
52 shared_ptr<FileAsset> dirAsset = nullptr;
53 if (!CreateAlbum(dir, nullptr, dirAsset)) {
54 isValid_ = false;
55 return;
56 }
57 rootDirAssetMap_[dir] = dirAsset;
58 }
59 }
60
CleanTestFiles()61 void MediaLibraryUnitTestUtils::CleanTestFiles()
62 {
63 system("rm -rf /storage/cloud/files/Audio/*");
64 system("rm -rf /storage/cloud/files/Audios/*");
65 system("rm -rf /storage/cloud/files/Camera/*");
66 system("rm -rf /storage/cloud/files/Documents/*");
67 system("rm -rf /storage/cloud/files/Photo/*");
68 system("rm -rf /storage/cloud/files/Pictures/*");
69 system("rm -rf /storage/cloud/files/Pictures/*");
70 system("rm -rf /storage/cloud/files/Videos/*");
71 system("rm -rf /storage/cloud/files/.*");
72 auto rdbStore = MediaLibraryDataManager::GetInstance()->rdbStore_;
73 NativeRdb::AbsRdbPredicates predicates(MEDIALIBRARY_TABLE);
74 predicates.GreaterThan(MEDIA_DATA_DB_ID, to_string(0));
75 int32_t deletedRows = -1;
76 auto ret = rdbStore->Delete(deletedRows, predicates);
77 MEDIA_INFO_LOG("CleanTestFiles Delete retVal: %{public}d, deletedRows: %{public}d", ret, deletedRows);
78 }
79
CleanBundlePermission()80 void MediaLibraryUnitTestUtils::CleanBundlePermission()
81 {
82 auto rdbStore = MediaLibraryDataManager::GetInstance()->rdbStore_;
83 NativeRdb::AbsRdbPredicates predicates(BUNDLE_PERMISSION_TABLE);
84 predicates.GreaterThan(MEDIA_DATA_DB_ID, to_string(0));
85 int32_t deletedRows = -1;
86 auto ret = rdbStore->Delete(deletedRows, predicates);
87 MEDIA_INFO_LOG("CleanBundlePermission Delete retVal: %{public}d, deletedRows: %{public}d", ret, deletedRows);
88 }
89
GetRootAsset(const string & dir)90 shared_ptr<FileAsset> MediaLibraryUnitTestUtils::GetRootAsset(const string &dir)
91 {
92 if (rootDirAssetMap_.find(dir) != rootDirAssetMap_.end()) {
93 return rootDirAssetMap_[dir];
94 }
95 return nullptr;
96 }
97
IsFileExists(const string filePath)98 bool MediaLibraryUnitTestUtils::IsFileExists(const string filePath)
99 {
100 struct stat statInfo {};
101 int errCode = stat(filePath.c_str(), &statInfo);
102 return (errCode == 0);
103 }
104
GetFileAsset(const int fileId,shared_ptr<FileAsset> & fileAsset)105 bool MediaLibraryUnitTestUtils::GetFileAsset(const int fileId, shared_ptr<FileAsset> &fileAsset)
106 {
107 if (!MediaLibraryUnitTestUtils::IsValid()) {
108 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
109 exit(1);
110 }
111 vector<string> columns;
112 DataSharePredicates predicates;
113 string selections = MEDIA_DATA_DB_ID + " = " + to_string(fileId);
114 predicates.SetWhereClause(selections);
115 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
116 int errCode = 0;
117 MediaLibraryCommand cmd(queryFileUri, Media::OperationType::QUERY);
118 auto resultSet = MediaLibraryDataManager::GetInstance()->Query(cmd, columns, predicates, errCode);
119 if (resultSet == nullptr) {
120 MEDIA_ERR_LOG("GetFileAsset::resultSet == nullptr");
121 return false;
122 }
123 auto result = make_shared<DataShareResultSet>(resultSet);
124 shared_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(move(result));
125 if (fetchFileResult->GetCount() <= 0) {
126 MEDIA_ERR_LOG("GetFileAsset::GetCount <= 0");
127 return false;
128 }
129 auto firstAsset = fetchFileResult->GetFirstObject();
130 fileAsset = move(firstAsset);
131 if (fileAsset == nullptr) {
132 MEDIA_ERR_LOG("GetFileAsset::fileAsset = nullptr.");
133 return false;
134 }
135 return true;
136 }
137
CreateAlbum(string displayName,shared_ptr<FileAsset> parentAlbumAsset,shared_ptr<FileAsset> & albumAsset)138 bool MediaLibraryUnitTestUtils::CreateAlbum(string displayName, shared_ptr<FileAsset> parentAlbumAsset,
139 shared_ptr<FileAsset> &albumAsset)
140 {
141 if (!MediaLibraryUnitTestUtils::IsValid()) {
142 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
143 exit(1);
144 }
145 Uri createAlbumUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_ALBUMOPRN + "/" + MEDIA_ALBUMOPRN_CREATEALBUM);
146 string dirPath;
147 if (parentAlbumAsset == nullptr) {
148 dirPath = ROOT_MEDIA_DIR + displayName;
149 } else {
150 dirPath = parentAlbumAsset->GetPath() + "/" + displayName;
151 }
152 DataShareValuesBucket valuesBucket;
153 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, dirPath);
154 valuesBucket.Put(MEDIA_DATA_DB_NAME, displayName);
155 MediaLibraryCommand cmd(createAlbumUri);
156 auto retVal = MediaLibraryDataManager::GetInstance()->Insert(cmd, valuesBucket);
157 MEDIA_INFO_LOG("CreateAlbum:: %{public}s, retVal: %{public}d", dirPath.c_str(), retVal);
158 if (retVal <= 0) {
159 MEDIA_ERR_LOG("CreateAlbum::create failed, %{public}s", dirPath.c_str());
160 return false;
161 }
162 if (!GetFileAsset(retVal, albumAsset)) {
163 MEDIA_ERR_LOG("CreateAlbum::GetFileAsset failed, %{public}s", dirPath.c_str());
164 return false;
165 }
166 return true;
167 }
168
CreateFile(string displayName,shared_ptr<FileAsset> parentAlbumAsset,shared_ptr<FileAsset> & fileAsset)169 bool MediaLibraryUnitTestUtils::CreateFile(string displayName, shared_ptr<FileAsset> parentAlbumAsset,
170 shared_ptr<FileAsset> &fileAsset)
171 {
172 if (!MediaLibraryUnitTestUtils::IsValid()) {
173 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
174 exit(1);
175 }
176 Uri createAssetUri(MEDIALIBRARY_DATA_URI + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET);
177 DataShareValuesBucket valuesBucket;
178 string relativePath = parentAlbumAsset->GetRelativePath() + parentAlbumAsset->GetDisplayName() + "/";
179 string mimeType = MimeTypeUtils::GetMimeTypeFromExtension(ScannerUtils::GetFileExtension(displayName));
180 MediaType mediaType = MimeTypeUtils::GetMediaTypeFromMimeType(mimeType);
181 valuesBucket.Put(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
182 valuesBucket.Put(MEDIA_DATA_DB_NAME, displayName);
183 valuesBucket.Put(MEDIA_DATA_DB_RELATIVE_PATH, relativePath);
184 MediaLibraryCommand cmd(createAssetUri);
185 int32_t retVal = MediaLibraryDataManager::GetInstance()->Insert(cmd, valuesBucket);
186 MEDIA_INFO_LOG("CreateFile:: %{public}s, retVal: %{public}d", (relativePath + displayName).c_str(), retVal);
187 if (retVal <= 0) {
188 MEDIA_ERR_LOG("CreateFile::create failed, %{public}s", (relativePath + displayName).c_str());
189 return false;
190 }
191 if (!GetFileAsset(retVal, fileAsset)) {
192 MEDIA_ERR_LOG("CreateFile::GetFileAsset failed, %{public}s", (relativePath + displayName).c_str());
193 return false;
194 }
195 return true;
196 }
197
CreateFileFS(const string & filePath)198 bool MediaLibraryUnitTestUtils::CreateFileFS(const string &filePath)
199 {
200 bool errCode = false;
201
202 if (filePath.empty()) {
203 return errCode;
204 }
205
206 ofstream file(filePath);
207 if (!file) {
208 MEDIA_ERR_LOG("Output file path could not be created");
209 return errCode;
210 }
211
212 const mode_t CHOWN_RW_UG = 0660;
213 if (chmod(filePath.c_str(), CHOWN_RW_UG) == 0) {
214 errCode = true;
215 }
216
217 file.close();
218
219 return errCode;
220 }
221
DeleteDir(const string & path,const string & dirId)222 bool MediaLibraryUnitTestUtils::DeleteDir(const string &path, const string &dirId)
223 {
224 string cmd = "rm -rf " + path;
225 system(cmd.c_str());
226
227 auto rdbStore = MediaLibraryDataManager::GetInstance()->rdbStore_;
228 NativeRdb::AbsRdbPredicates predicates(MEDIALIBRARY_TABLE);
229 predicates.EqualTo(MEDIA_DATA_DB_ID, dirId)->Or()->EqualTo(MEDIA_DATA_DB_PARENT_ID, dirId);
230 int32_t deletedRows = -1;
231 auto ret = rdbStore->Delete(deletedRows, predicates);
232 return ret == 0;
233 }
234
TrashFile(shared_ptr<FileAsset> & fileAsset)235 void MediaLibraryUnitTestUtils::TrashFile(shared_ptr<FileAsset> &fileAsset)
236 {
237 DataShareValuesBucket valuesBucket;
238 valuesBucket.Put(SMARTALBUMMAP_DB_ALBUM_ID, TRASH_ALBUM_ID_VALUES);
239 valuesBucket.Put(SMARTALBUMMAP_DB_CHILD_ASSET_ID, fileAsset->GetId());
240 string uriString = MEDIALIBRARY_DATA_URI + "/" + MEDIA_SMARTALBUMMAPOPRN + "/" +
241 MEDIA_SMARTALBUMMAPOPRN_ADDSMARTALBUM;
242 Uri uri(uriString);
243 MediaLibraryCommand cmd(uri);
244 MediaLibraryDataManager::GetInstance()->Insert(cmd, valuesBucket);
245 }
246
RecoveryFile(shared_ptr<FileAsset> & fileAsset)247 void MediaLibraryUnitTestUtils::RecoveryFile(shared_ptr<FileAsset> &fileAsset)
248 {
249 DataShareValuesBucket valuesBucket;
250 valuesBucket.Put(SMARTALBUMMAP_DB_ALBUM_ID, TRASH_ALBUM_ID_VALUES);
251 valuesBucket.Put(SMARTALBUMMAP_DB_CHILD_ASSET_ID, fileAsset->GetId());
252 string uriString = MEDIALIBRARY_DATA_URI + "/" + MEDIA_SMARTALBUMMAPOPRN + "/" +
253 MEDIA_SMARTALBUMMAPOPRN_REMOVESMARTALBUM;
254 Uri uri(uriString);
255 MediaLibraryCommand cmd(uri);
256 MediaLibraryDataManager::GetInstance()->Insert(cmd, valuesBucket);
257 }
258
WaitForCallback(shared_ptr<TestScannerCallback> callback)259 void MediaLibraryUnitTestUtils::WaitForCallback(shared_ptr<TestScannerCallback> callback)
260 {
261 std::mutex mutex;
262 std::unique_lock<std::mutex> lock(mutex);
263 const int waitSeconds = 10;
264 callback->condVar_.wait_until(lock, std::chrono::system_clock::now() + std::chrono::seconds(waitSeconds));
265 }
266
GrantUriPermission(const int32_t fileId,const string & bundleName,const string & mode,const int32_t tableType)267 int32_t MediaLibraryUnitTestUtils::GrantUriPermission(const int32_t fileId, const string &bundleName,
268 const string &mode, const int32_t tableType)
269 {
270 Uri addPermission(MEDIALIBRARY_BUNDLEPERM_URI + "/" + BUNDLE_PERMISSION_INSERT);
271 DataShareValuesBucket values;
272 values.Put(PERMISSION_FILE_ID, fileId);
273 values.Put(PERMISSION_BUNDLE_NAME, bundleName);
274 values.Put(PERMISSION_MODE, mode);
275 values.Put(PERMISSION_TABLE_TYPE, tableType);
276 MediaLibraryCommand cmd(addPermission);
277 return MediaLibraryDataManager::GetInstance()->Insert(cmd, values);
278 }
279
TestScannerCallback()280 TestScannerCallback::TestScannerCallback() : status_(-1) {}
281
OnScanFinished(const int32_t status,const std::string & uri,const std::string & path)282 int32_t TestScannerCallback::OnScanFinished(const int32_t status, const std::string &uri, const std::string &path)
283 {
284 status_ = status;
285 condVar_.notify_all();
286 return E_OK;
287 }
288 }
289 }
290