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 #include "ringtone_scanner_db_test.h"
17
18 #include <string>
19
20 #include "ability_context_impl.h"
21 #include "rdb_helper.h"
22 #include "ringtone_data_manager.h"
23 #include "ringtone_errno.h"
24 #include "ringtone_log.h"
25 #include "ringtone_rdbstore.h"
26 #define private public
27 #include "ringtone_scanner_db.h"
28 #undef private
29 #include "ringtone_unittest_utils.h"
30 #include "ringtone_scanner_utils.h"
31 #include "ringtone_type.h"
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace Media {
39 class ConfigTestOpenCall : public NativeRdb::RdbOpenCallback {
40 public:
41 int OnCreate(NativeRdb::RdbStore &rdbStore) override;
42 int OnUpgrade(NativeRdb::RdbStore &rdbStore, int oldVersion, int newVersion) override;
43 static const string CREATE_TABLE_TEST;
44 };
45
46 const string ConfigTestOpenCall::CREATE_TABLE_TEST = string("CREATE TABLE IF NOT EXISTS test ") +
47 "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, age INTEGER, salary REAL, blobType BLOB)";
48
OnCreate(NativeRdb::RdbStore & store)49 int ConfigTestOpenCall::OnCreate(NativeRdb::RdbStore &store)
50 {
51 return store.ExecuteSql(CREATE_TABLE_TEST);
52 }
53
OnUpgrade(NativeRdb::RdbStore & store,int oldVersion,int newVersion)54 int ConfigTestOpenCall::OnUpgrade(NativeRdb::RdbStore &store, int oldVersion, int newVersion)
55 {
56 return 0;
57 }
58 shared_ptr<RingtoneUnistore> g_uniStore = nullptr;
59
SetUpTestCase()60 void RingtoneScannerDbTest::SetUpTestCase() {}
61
TearDownTestCase()62 void RingtoneScannerDbTest::TearDownTestCase() {}
63
64 // SetUp:Execute before each test case
SetUp()65 void RingtoneScannerDbTest::SetUp()
66 {
67 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
68 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
69 EXPECT_NE(abilityContextImpl, nullptr);
70 abilityContextImpl->SetStageContext(stageContext);
71 g_uniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
72 EXPECT_NE(g_uniStore, nullptr);
73 int32_t ret = g_uniStore->Init();
74 EXPECT_EQ(ret, E_OK);
75 }
76
TearDown(void)77 void RingtoneScannerDbTest::TearDown(void) {}
78
79 HWTEST_F(RingtoneScannerDbTest, scannerDb_QueryRingtoneRdb_test_001, TestSize.Level0)
80 {
81 RingtoneScannerDb ringtoneScannerDb;
82 string whereClause = {};
83 vector<string> whereArgs = {};
84 vector<string> columns;
85 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
86 int ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
87 EXPECT_EQ(ret, E_OK);
88 g_uniStore->Stop();
89 ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
90 EXPECT_EQ(ret, E_RDB);
91 }
92
93 HWTEST_F(RingtoneScannerDbTest, scannerDb_InsertMetadata_test_001, TestSize.Level0)
94 {
95 RingtoneScannerDb ringtoneScannerDb;
96 RingtoneMetadata metadata;
97 string tableName;
98 g_uniStore->Stop();
99 int32_t ret = ringtoneScannerDb.InsertMetadata(metadata, tableName);
100 // stop g_uniStore will cause insert failed
101 EXPECT_EQ(ret, E_DB_FAIL);
102 struct stat statInfo;
103 metadata.SetData(STORAGE_FILES_DIR);
104 metadata.SetDisplayName(RingtoneScannerUtils::GetFileNameFromUri(STORAGE_FILES_DIR));
105 metadata.SetTitle(RingtoneScannerUtils::GetFileTitle(metadata.GetDisplayName()));
106 metadata.SetMediaType(static_cast<RingtoneMediaType>(RINGTONE_MEDIA_TYPE_AUDIO));
107 metadata.SetSize(statInfo.st_size);
108 metadata.SetDateModified(statInfo.st_mtime);
109 const int64_t DATE_TAKEN = 1;
110 metadata.SetDateTaken(DATE_TAKEN);
111 ret = ringtoneScannerDb.InsertMetadata(metadata, tableName);
112 EXPECT_EQ(ret, E_DB_FAIL);
113 const int64_t DATE_ADD = 1;
114 metadata.SetDateAdded(DATE_ADD);
115 ret = ringtoneScannerDb.InsertMetadata(metadata, tableName);
116 EXPECT_EQ(ret, E_DB_FAIL);
117 }
118
119 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateMetadata_test_001, TestSize.Level0)
120 {
121 RingtoneScannerDb ringtoneScannerDb;
122 RingtoneMetadata metadata;
123 string tableName;
124 g_uniStore->Stop();
125 int32_t ret = ringtoneScannerDb.UpdateMetadata(metadata, tableName);
126 EXPECT_EQ(ret, E_RDB);
127 }
128
129 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateRingtoneRdb_test_001, TestSize.Level0)
130 {
131 RingtoneScannerDb ringtoneScannerDb;
132 NativeRdb::ValuesBucket valuesBucket;
133 string whereClause = {};
134 vector<string> whereArgs = {};
135 int ret = ringtoneScannerDb.UpdateRingtoneRdb(valuesBucket, whereClause, whereArgs);
136 EXPECT_EQ(ret, E_DB_FAIL);
137 g_uniStore->Stop();
138 ret = ringtoneScannerDb.UpdateRingtoneRdb(valuesBucket, whereClause, whereArgs);
139 EXPECT_EQ(ret, E_RDB);
140 }
141
142 HWTEST_F(RingtoneScannerDbTest, scannerDb_GetFileBasicInfo_test_001, TestSize.Level0)
143 {
144 RingtoneScannerDb ringtoneScannerDb;
145 const string path = "scannerDb_GetFileBasicInfo_test_001";
146 unique_ptr<RingtoneMetadata> metadata = make_unique<RingtoneMetadata>();
147 metadata->SetData(STORAGE_FILES_DIR);
148 metadata->SetDisplayName(RingtoneScannerUtils::GetFileNameFromUri(STORAGE_FILES_DIR));
149 metadata->SetTitle(RingtoneScannerUtils::GetFileTitle(metadata->GetDisplayName()));
150 metadata->SetMediaType(static_cast<RingtoneMediaType>(RINGTONE_MEDIA_TYPE_AUDIO));
151 g_uniStore->Stop();
152 int ret = ringtoneScannerDb.GetFileBasicInfo(path, metadata);
153 EXPECT_EQ(ret, E_DB_FAIL);
154 }
155
156 /*
157 * Feature: Service
158 * Function: Test ringtoneScannerDb with UpdateScannerFlag
159 * SubFunction: NA
160 * FunctionPoints: NA
161 * EnvConditions: NA
162 * CaseDescription: Test UpdateScannerFlag for Normal branches
163 */
164 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateScannerFlag_test_001, TestSize.Level0)
165 {
166 RINGTONE_INFO_LOG("scannerDb_UpdateScannerFlag_test_001 start.");
167 RingtoneScannerDb ringtoneScannerDb;
168 g_uniStore->ExecuteSql("INSERT INTO " + RINGTONE_TABLE +
169 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/alarms/Adara.ogg'," +
170 " 10414, 'Adara.ogg', 'Adara', 2, 0, 'audio/ogg', 2, 1505707241000, 1505707241846, 1505707241," +
171 " 600, 0, -1, 0, -1, 0, -1, 1, 2, '1', 1)");
172 bool res = ringtoneScannerDb.UpdateScannerFlag();
173 EXPECT_EQ(res, true);
174
175 string whereClause = RINGTONE_COLUMN_DISPLAY_NAME + " = ?";
176 vector<string> whereArgs;
177 whereArgs.push_back("Adara.ogg");
178 vector<string> columns = {RINGTONE_COLUMN_SCANNER_FLAG};
179 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
180 int ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
181 ASSERT_NE(resultSet, nullptr);
182 EXPECT_EQ(ret, E_OK);
183 int scannerFlag;
184 resultSet->GetInt(0, scannerFlag);
185 EXPECT_EQ(scannerFlag, 0);
186 RINGTONE_INFO_LOG("scannerDb_UpdateScannerFlag_test_001 end.");
187 }
188
189 /*
190 * Feature: Service
191 * Function: Test ringtoneScannerDb with DeleteNotExist
192 * SubFunction: NA
193 * FunctionPoints: NA
194 * EnvConditions: NA
195 * CaseDescription: Test DeleteNotExist for Normal branches
196 */
197 HWTEST_F(RingtoneScannerDbTest, scannerDb_DeleteNotExist_test_001, TestSize.Level0)
198 {
199 RINGTONE_INFO_LOG("scannerDb_DeleteNotExist_test_001 start.");
200 RingtoneScannerDb ringtoneScannerDb;
201 g_uniStore->ExecuteSql("INSERT INTO " + RINGTONE_TABLE +
202 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/ringtones/Carme.ogg'," +
203 " 26177, 'RingtoneTest.ogg', 'RingtoneTest', 2, 1, 'audio/ogg', 1, 1505707241000, 1505707241846, 1505707241," +
204 " 1242, 0, -1, 0, -1, 3, 2, 0, -1, '1', 0)");
205 string whereClause = RINGTONE_COLUMN_DISPLAY_NAME + " = ?";
206 vector<string> whereArgs = {};
207 whereArgs.push_back("RingtoneTest.ogg");
208 vector<string> columns = {RINGTONE_COLUMN_SCANNER_FLAG};
209 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
210 int ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
211 ASSERT_NE(resultSet, nullptr);
212 EXPECT_EQ(ret, E_OK);
213 int scannerFlag;
214 resultSet->GetInt(0, scannerFlag);
215 EXPECT_EQ(scannerFlag, 0);
216
217 bool res = ringtoneScannerDb.DeleteNotExist();
218 EXPECT_EQ(res, true);
219 resultSet = nullptr;
220 ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
221 ASSERT_NE(resultSet, nullptr);
222 EXPECT_EQ(ret, E_OK);
223 int rowCount = 1;
224 resultSet->GetRowCount(rowCount);
225 EXPECT_EQ(rowCount, 0);
226 RINGTONE_INFO_LOG("scannerDb_DeleteNotExist_test_001 end.");
227 }
228
229 /*
230 * Feature: Service
231 * Function: Test ringtoneScannerDb with QueryRingtoneRdb
232 * SubFunction: NA
233 * FunctionPoints: NA
234 * EnvConditions: NA
235 * CaseDescription: Test QueryRingtoneRdb when column is not exist
236 */
237 HWTEST_F(RingtoneScannerDbTest, scannerDb_QueryRingtoneRdb_test_002, TestSize.Level0)
238 {
239 RINGTONE_INFO_LOG("scannerDb_QueryRingtoneRdb_test_002 start.");
240 RingtoneScannerDb ringtoneScannerDb;
241 g_uniStore->ExecuteSql("INSERT INTO " + RINGTONE_TABLE +
242 " VALUES (last_insert_rowid()+1, '/data/storage/el2/base/files/Ringtone/ringtones/Carme.ogg'," +
243 " 26177, 'Ringtone.ogg', 'RingtoneTest', 2, 1, 'audio/ogg', 1, 1505707241000, 1505707241846, 1505707241," +
244 " 1242, 0, -1, 0, -1, 3, 2, 0, -1, '1', 0)");
245 string whereClause = "test = ?";
246 vector<string> whereArgs = {};
247 whereArgs.push_back("Ringtone.ogg");
248 vector<string> columns = {"test"};
249 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
250 int ret = ringtoneScannerDb.QueryRingtoneRdb(whereClause, whereArgs, columns, resultSet);
251 EXPECT_EQ(ret, E_OK);
252 RINGTONE_INFO_LOG("scannerDb_QueryRingtoneRdb_test_002 end.");
253 }
254
255 /*
256 * Feature: Service
257 * Function: Test ringtoneScannerDb with InsertVibrateMetadata
258 * SubFunction: NA
259 * FunctionPoints: NA
260 * EnvConditions: NA
261 * CaseDescription: Test InsertVibrateMetadata for normal branches
262 */
263 HWTEST_F(RingtoneScannerDbTest, scannerDb_InsertVibrateMetadata_test_001, TestSize.Level0)
264 {
265 RINGTONE_INFO_LOG("scannerDb_InsertVibrateMetadata_test_001 start.");
266 RingtoneScannerDb ringtoneScannerDb;
267 VibrateMetadata* metadata = new (std::nothrow) VibrateMetadata();
268 ASSERT_NE(metadata, nullptr);
269 metadata->SetData("test");
270 metadata->SetDateAdded(static_cast<int64_t>(0));
271 metadata->SetDateTaken(static_cast<int64_t>(0));
272 metadata->SetDateModified(static_cast<int64_t>(0));
273 std::string tableName = VIBRATE_TABLE;
274 int32_t ret = ringtoneScannerDb.InsertVibrateMetadata(*metadata, tableName);
275 EXPECT_NE(ret, 0);
276
277 metadata->SetDateTaken(static_cast<int64_t>(1));
278 ret = ringtoneScannerDb.InsertVibrateMetadata(*metadata, tableName);
279 EXPECT_NE(ret, 0);
280 RINGTONE_INFO_LOG("scannerDb_InsertVibrateMetadata_test_001 end.");
281 }
282
283 HWTEST_F(RingtoneScannerDbTest, scannerDb_GetVibrateFileBasicInfo_test_001, TestSize.Level0)
284 {
285 RINGTONE_INFO_LOG("scannerDb_GetVibrateFileBasicInfo_test_001 start.");
286 RingtoneScannerDb ringtoneScannerDb;
287 const string path = "scannerDb_GetVibrateFileBasicInfo_test_001";
288 unique_ptr<VibrateMetadata> metadata = make_unique<VibrateMetadata>();
289 EXPECT_NE(metadata, nullptr);
290 metadata->SetData(STORAGE_FILES_DIR);
291 metadata->SetDisplayName(RingtoneScannerUtils::GetFileNameFromUri(STORAGE_FILES_DIR));
292 metadata->SetTitle(RingtoneScannerUtils::GetFileTitle(metadata->GetDisplayName()));
293 g_uniStore->Stop();
294 int ret = ringtoneScannerDb.GetVibrateFileBasicInfo(path, metadata);
295 EXPECT_EQ(ret, E_DB_FAIL);
296 RINGTONE_INFO_LOG("scannerDb_GetVibrateFileBasicInfo_test_001 end.");
297 }
298
299 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateRingtoneRdb_test_002, TestSize.Level0)
300 {
301 RINGTONE_INFO_LOG("scannerDb_UpdateRingtoneRdb_test_002 start.");
302 RingtoneScannerDb ringtoneScannerDb;
303 NativeRdb::ValuesBucket valuesBucket;
304 valuesBucket.PutInt(RINGTONE_COLUMN_SCANNER_FLAG, 0);
305 string whereClause = RINGTONE_COLUMN_DISPLAY_NAME + " = ?";
306 vector<string> whereArgs = {};
307 whereArgs.push_back("RingtoneTest.ogg");
308 int ret = ringtoneScannerDb.UpdateRingtoneRdb(valuesBucket, whereClause, whereArgs);
309 EXPECT_EQ(ret, E_OK);
310 RINGTONE_INFO_LOG("scannerDb_UpdateRingtoneRdb_test_002 end.");
311 }
312
313 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateMetadata_test_002, TestSize.Level0)
314 {
315 RingtoneScannerDb ringtoneScannerDb;
316 RingtoneMetadata metadata;
317 string tableName;
318 metadata.SetToneId(1024);
319 int32_t ret = ringtoneScannerDb.UpdateMetadata(metadata, tableName);
320 EXPECT_EQ(ret, E_DB_FAIL);
321 }
322
323 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateVibrateMetadata_test_002, TestSize.Level0)
324 {
325 RingtoneScannerDb ringtoneScannerDb;
326 VibrateMetadata metadata;
327 string tableName;
328 metadata.SetVibrateId(1024);
329 int32_t ret = ringtoneScannerDb.UpdateVibrateMetadata(metadata, tableName);
330 EXPECT_EQ(ret, E_DB_FAIL);
331 }
332
333 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateVibrateMetadata_test_001, TestSize.Level0)
334 {
335 RingtoneScannerDb ringtoneScannerDb;
336 VibrateMetadata metadata;
337 string tableName;
338 g_uniStore->Stop();
339 int32_t ret = ringtoneScannerDb.UpdateVibrateMetadata(metadata, tableName);
340 EXPECT_EQ(ret, E_RDB);
341 }
342
343 HWTEST_F(RingtoneScannerDbTest, scannerDb_InsertVibrateMetadata_test_002, TestSize.Level0)
344 {
345 RingtoneScannerDb ringtoneScannerDb;
346 VibrateMetadata metadata;
347 string tableName;
348 g_uniStore->Stop();
349 int32_t ret = ringtoneScannerDb.InsertVibrateMetadata(metadata, tableName);
350 EXPECT_EQ(ret, E_DB_FAIL);
351 }
352
353 HWTEST_F(RingtoneScannerDbTest, scannerDb_UpdateScannerFlag_test_002, TestSize.Level0)
354 {
355 RingtoneScannerDb ringtoneScannerDb;
356 VibrateMetadata metadata;
357 string tableName;
358 g_uniStore->Stop();
359 bool ret = ringtoneScannerDb.UpdateScannerFlag();
360 EXPECT_FALSE(ret);
361 }
362
363 HWTEST_F(RingtoneScannerDbTest, scannerDb_DeleteNotExist_test_002, TestSize.Level0)
364 {
365 RingtoneScannerDb ringtoneScannerDb;
366 VibrateMetadata metadata;
367 string tableName;
368 g_uniStore->Stop();
369 bool ret = ringtoneScannerDb.DeleteNotExist();
370 EXPECT_FALSE(ret);
371 }
372 } // namespace Media
373 } // namespace OHOS
374