1 /*
2 * Copyright (C) 2021-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 #include "datashare_helper.h"
16 #include "fetch_result.h"
17 #include "get_self_permissions.h"
18 #include "iservice_registry.h"
19 #include "medialibrary_errno.h"
20 #include "mediascanner_unit_test.h"
21 #include "media_file_utils.h"
22 #include "media_library_manager.h"
23 #include "media_log.h"
24 #include "media_scanner_manager.h"
25 #include "system_ability_definition.h"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Media {
32 namespace {
33 string g_prefixPath = "/storage/media/local/files";
34 const mode_t CHOWN_RW_UG = 0660;
35 }
36 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
37 std::shared_ptr<DataShare::DataShareHelper> g_mediaDataShareHelper;
38
CreateDataShareHelper(int32_t systemAbilityId)39 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId)
40 {
41 MEDIA_INFO_LOG("CreateDataShareHelper::CreateFileExtHelper ");
42 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
43 if (saManager == nullptr) {
44 MEDIA_INFO_LOG("CreateDataShareHelper::CreateFileExtHelper Get system ability mgr failed.");
45 return nullptr;
46 }
47 auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
48 while (remoteObj == nullptr) {
49 MEDIA_INFO_LOG("CreateDataShareHelper::CreateFileExtHelper GetSystemAbility Service Failed.");
50 return nullptr;
51 }
52 return DataShare::DataShareHelper::Creator(remoteObj, MEDIALIBRARY_DATA_URI);
53 }
CreateFile(const string & filePath)54 bool CreateFile(const string &filePath)
55 {
56 bool errCode = false;
57
58 if (filePath.empty()) {
59 return errCode;
60 }
61
62 ofstream file(filePath);
63 if (!file) {
64 MEDIA_ERR_LOG("Output file path could not be created");
65 return errCode;
66 }
67
68 if (chmod(filePath.c_str(), CHOWN_RW_UG) == 0) {
69 errCode = true;
70 }
71
72 file.close();
73
74 return errCode;
75 }
76
SetUpTestCase(void)77 void MediaScannerUnitTest::SetUpTestCase(void)
78 {
79 vector<string> perms;
80 perms.push_back("ohos.permission.READ_MEDIA");
81 perms.push_back("ohos.permission.WRITE_MEDIA");
82 perms.push_back("ohos.permission.FILE_ACCESS_MANAGER");
83 uint64_t tokenId = 0;
84 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaDataShareUnitTest", perms, tokenId);
85 ASSERT_TRUE(tokenId != 0);
86
87 MEDIA_INFO_LOG("SetUpTestCase invoked");
88 g_mediaDataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
89 ASSERT_TRUE(g_mediaDataShareHelper != nullptr);
90
91 Uri deleteAssetUri(MEDIALIBRARY_DATA_URI);
92 DataShare::DataSharePredicates predicates;
93 string selections = MEDIA_DATA_DB_ID + " <> 0 ";
94 predicates.SetWhereClause(selections);
95 int retVal = g_mediaDataShareHelper->Delete(deleteAssetUri, predicates);
96 MEDIA_INFO_LOG("SetUpTestCase Delete retVal: %{public}d", retVal);
97 EXPECT_EQ((retVal >= 0), true);
98 }
99
TearDownTestCase(void)100 void MediaScannerUnitTest::TearDownTestCase(void) {}
ConvertPath(string path)101 string ConvertPath(string path)
102 {
103 string tmp = "/storage/media/100/";
104 path = tmp + path.substr(strlen("/storage/media/"));
105 return path;
106 }
SetUp(void)107 void MediaScannerUnitTest::SetUp(void) {}
TearDown(void)108 void MediaScannerUnitTest::TearDown(void) {}
109
110 /*
111 * Feature: MediaScanner
112 * Function: Scan a directory with media files
113 * SubFunction: NA
114 * FunctionPoints: NA
115 * EnvConditions: NA
116 * CaseDescription:
117 */
118 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanDir_test_001, TestSize.Level0)
119 {
120 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
121 DataShareValuesBucket valuesBucket;
122 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
123 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
124 EXPECT_EQ(ret, E_SUCCESS);
125 }
126
127 /*
128 * Feature : MediaScannerUnitTest
129 * Function : Scan a jpg image file
130 * SubFunction : NA
131 * FunctionPoints : NA
132 * EnvContions : NA
133 * CaseDescription : NA
134 */
135 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanImage_Test_001, TestSize.Level0)
136 {
137 bool createRes = CreateFile("/storage/media/100/local/files/Pictures/gtest_Image1.jpg");
138 EXPECT_EQ(createRes, true);
139
140 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
141 DataShareValuesBucket valuesBucket;
142 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
143 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
144 EXPECT_EQ(ret, E_SUCCESS);
145 }
146
147 /*
148 * Feature : MediaScannerUnitTest
149 * Function : Scan a png image file
150 * SubFunction : NA
151 * FunctionPoints : NA
152 * EnvContions : NA
153 * CaseDescription : NA
154 */
155 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanImage_Test_002, TestSize.Level0)
156 {
157 bool createRes = CreateFile("/storage/media/100/local/files/Pictures/gtest_Image2.png");
158 EXPECT_EQ(createRes, true);
159
160 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
161 DataShareValuesBucket valuesBucket;
162 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
163 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
164 EXPECT_EQ(ret, E_SUCCESS);
165 }
166
167 /*
168 * Feature : MediaScannerUnitTest
169 * Function : Scan an audio file
170 * SubFunction : NA
171 * FunctionPoints : NA
172 * EnvContions : NA
173 * CaseDescription : NA
174 */
175 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanImage_Test_003, TestSize.Level0)
176 {
177 bool createRes = CreateFile("/storage/media/100/local/files/Pictures/gtest_Image3.jpeg");
178 EXPECT_EQ(createRes, true);
179
180 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
181 DataShareValuesBucket valuesBucket;
182 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
183 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
184 EXPECT_EQ(ret, E_SUCCESS);
185 }
186
187 /*
188 * Feature : MediaScannerUnitTest
189 * Function : Scan a normal text file
190 * SubFunction : NA
191 * FunctionPoints : NA
192 * EnvContions : NA
193 * CaseDescription : NA
194 */
195 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanTextFile_Test_001, TestSize.Level0)
196 {
197 bool createRes = CreateFile("/storage/media/100/local/files/Documents/gtest_Text1.txt");
198 EXPECT_EQ(createRes, true);
199
200 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
201 DataShareValuesBucket valuesBucket;
202 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
203 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
204 EXPECT_EQ(ret, E_SUCCESS);
205 }
206
207 /*
208 * Feature : MediaScannerUnitTest
209 * Function : Scan a hidden file
210 * SubFunction : NA
211 * FunctionPoints : NA
212 * EnvContions : NA
213 * CaseDescription : NA
214 */
215 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanHiddenFile_Test_001, TestSize.Level0)
216 {
217 bool createRes = CreateFile("/storage/media/100/local/files/Download/.HiddenFile");
218 EXPECT_EQ(createRes, true);
219
220 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
221 DataShareValuesBucket valuesBucket;
222 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
223 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
224 EXPECT_EQ(ret, E_SUCCESS);
225 }
226
227 /*
228 * Feature: MediaScanner
229 * Function: Scan a directory with image, video, audio and other type of files
230 * SubFunction: NA
231 * FunctionPoints: NA
232 * EnvConditions: NA
233 * CaseDescription:
234 */
235 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanDir_test_002, TestSize.Level0)
236 {
237 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
238 DataShareValuesBucket valuesBucket;
239 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
240 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
241 EXPECT_EQ(ret, E_SUCCESS);
242 }
243
244 /*
245 * Feature: MediaScanner
246 * Function: Scan a directory with path provided as relative, must convert to canonical form
247 * SubFunction: NA
248 * FunctionPoints: NA
249 * EnvConditions: NA
250 * CaseDescription:
251 */
252 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanDir_CononicalPathtest_001, TestSize.Level0)
253 {
254 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
255 DataShareValuesBucket valuesBucket;
256 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
257 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
258 EXPECT_EQ(ret, E_SUCCESS);
259 }
260
261 /*
262 * Feature: MediaScanner
263 * Function: Scan an image file with path provided as relative, must convert to canonical form
264 * SubFunction: NA
265 * FunctionPoints: NA
266 * EnvConditions: NA
267 * CaseDescription:
268 */
269 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanFile_CononicalPathtest_001, TestSize.Level0)
270 {
271 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
272 DataShareValuesBucket valuesBucket;
273 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
274 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
275 EXPECT_EQ(ret, E_SUCCESS);
276 }
277
278 /*
279 * Feature: MediaScanner
280 * Function: Scan a text file with path provided as relative, must convert to canonical form
281 * SubFunction: NA
282 * FunctionPoints: NA
283 * EnvConditions: NA
284 * CaseDescription:
285 */
286 HWTEST_F(MediaScannerUnitTest, mediascanner_ScanFile_CononicalPathtest_002, TestSize.Level0)
287 {
288 MEDIA_DEBUG_LOG("mediascanner_ScanFile_CononicalPathtest_002 start");
289 Uri scanUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_BOARDCASTOPRN);
290 DataShareValuesBucket valuesBucket;
291 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
292 auto ret = g_mediaDataShareHelper->Insert(scanUri, valuesBucket);
293 EXPECT_EQ(ret, E_SUCCESS);
294 MEDIA_DEBUG_LOG("mediascanner_ScanFile_CononicalPathtest_002 end");
295 }
296 } // namespace Media
297 } // namespace OHOS
298
