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_datashare_extension_test.h"
17
18 #include "ability_context_impl.h"
19 #include "ability_handler.h"
20 #include "ability_info.h"
21 #include "datashare_ext_ability.h"
22 #include "dfx_const.h"
23 #include "get_self_permissions.h"
24 #include "ohos_application.h"
25 #include "preferences_helper.h"
26 #define private public
27 #include "ringtone_data_manager.h"
28 #include "ringtone_datashare_stub_impl.h"
29 #undef private
30 #include "ringtone_db_const.h"
31 #include "ringtone_errno.h"
32 #include "ringtone_file_utils.h"
33 #include "ringtone_rdbstore.h"
34 #include "ringtone_type.h"
35 #include "runtime.h"
36
37
38 using namespace std;
39 using namespace OHOS;
40 using namespace testing::ext;
41
42 namespace OHOS {
43 namespace Media {
44
45 static const char RINGTONE_RDB_SCANNER_FLAG_KEY[] = "RDBInitScanner";
46 static const int RINGTONE_RDB_SCANNER_FLAG_KEY_TRUE = 1;
47 static const int RINGTONE_RDB_SCANNER_FLAG_KEY_FALSE = 0;
48
SetUpTestCase()49 void RingtoneDataShareExtensionTest::SetUpTestCase()
50 {
51 vector<string> perms;
52 perms.push_back("ohos.permission.WRITE_RINGTONE");
53
54 uint64_t tokenId = 0;
55 RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneDataManagerUnitTest", perms, tokenId);
56 ASSERT_TRUE(tokenId != 0);
57 }
TearDownTestCase()58 void RingtoneDataShareExtensionTest::TearDownTestCase() {}
59
60 // SetUp:Execute before each test case
SetUp()61 void RingtoneDataShareExtensionTest::SetUp() {}
62
TearDown()63 void RingtoneDataShareExtensionTest::TearDown() {}
64
65 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_OnConnect_test_001, TestSize.Level0)
66 {
67 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
68 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
69 AbilityRuntime::DataShareExtAbility::Create(runtime);
70 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
71 ASSERT_TRUE(mediaDataShare != nullptr);
72
73 std::shared_ptr<AppExecFwk::AbilityLocalRecord> record = nullptr;
74 const std::shared_ptr<AppExecFwk::OHOSApplication> application = nullptr;
75 std::shared_ptr<AppExecFwk::AbilityHandler> handler = nullptr;
76 const sptr<IRemoteObject> token = nullptr;
77 mediaDataShare->Init(record, application, handler, token);
78
79 std::shared_ptr<AbilityRuntime::AbilityInfo> info = std::make_shared<AbilityRuntime::AbilityInfo>();
80 info->name = "start";
81 napi_env env = nullptr;
82 shared_ptr<DataShare::RingtoneDataShareExtension> extension(mediaDataShare);
83 sptr<DataShare::RingtoneDataShareStubImpl> remoteObject =
84 new DataShare::RingtoneDataShareStubImpl(extension, env);
85 auto recordTwo = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, token, nullptr, 0);
86 mediaDataShare->Init(recordTwo, application, handler, token);
87 std::shared_ptr<AppExecFwk::OHOSApplication> applicationTwo = std::make_shared<AppExecFwk::OHOSApplication>();
88 mediaDataShare->Init(recordTwo, applicationTwo, handler, token);
89 std::shared_ptr<AbilityRuntime::EventRunner> runner = nullptr;
90 std::shared_ptr<AppExecFwk::AbilityHandler> handlerTwo = make_shared<AppExecFwk::AbilityHandler>(runner);
91 mediaDataShare->Init(recordTwo, applicationTwo, handlerTwo, token);
92 const sptr<IRemoteObject> tokenTwo = remoteObject->AsObject();
93 mediaDataShare->Init(recordTwo, applicationTwo, handlerTwo, tokenTwo);
94 AAFwk::Want want;
95 auto ret = mediaDataShare->OnConnect(want);
96 EXPECT_EQ((ret != nullptr), true);
97 mediaDataShare->OnStart(want);
98 mediaDataShare->OnStop();
99 ret = mediaDataShare->OnConnect(want);
100 EXPECT_EQ((ret != nullptr), true);
101 }
102
103 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Insert_test_001, TestSize.Level0)
104 {
105 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
106 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
107 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
108 EXPECT_EQ(mediaDataShare != nullptr, true);
109
110 Uri uri(RINGTONE_PATH_URI);
111 AbilityRuntime::DataShareValuesBucket values;
112 auto ret = mediaDataShare->Insert(uri, values);
113 EXPECT_EQ(ret, E_COMMON_START);
114
115 Uri uriError(RINGTONE_URI);
116 ret = mediaDataShare->Insert(uriError, values);
117 EXPECT_EQ(ret, E_INVALID_URI);
118 }
119
120 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Update_test_001, TestSize.Level0)
121 {
122 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
123 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
124 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
125 EXPECT_EQ(mediaDataShare != nullptr, true);
126
127 Uri uri(RINGTONE_PATH_URI);
128 const AbilityRuntime::DataSharePredicates predicates;
129 AbilityRuntime::DataShareValuesBucket values;
130 auto ret = mediaDataShare->Update(uri, predicates, values);
131 EXPECT_EQ(ret, E_COMMON_START);
132
133 Uri uriError(RINGTONE_URI);
134 ret = mediaDataShare->Update(uriError, predicates, values);
135 EXPECT_EQ(ret, E_INVALID_URI);
136 }
137
138 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Delete_test_001, TestSize.Level0)
139 {
140 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
141 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
142 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
143 EXPECT_EQ(mediaDataShare != nullptr, true);
144
145 Uri uri(RINGTONE_PATH_URI);
146 const AbilityRuntime::DataSharePredicates predicates;
147 auto ret = mediaDataShare->Delete(uri, predicates);
148 EXPECT_EQ(ret, E_COMMON_START);
149
150 Uri uriError(RINGTONE_URI);
151 ret = mediaDataShare->Delete(uriError, predicates);
152 EXPECT_EQ(ret, E_INVALID_URI);
153 }
154
155 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Query_test_001, TestSize.Level0)
156 {
157 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
158 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
159 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
160 EXPECT_EQ(mediaDataShare != nullptr, true);
161
162 Uri uri(RINGTONE_PATH_URI);
163 vector<string> columns;
164 const AbilityRuntime::DataSharePredicates predicates;
165 AbilityRuntime::DatashareBusinessError businessError;
166 auto ret = mediaDataShare->Query(uri, predicates, columns, businessError);
167 EXPECT_EQ(ret, nullptr);
168
169 Uri uriError(RINGTONE_URI);
170 ret = mediaDataShare->Query(uriError, predicates, columns, businessError);
171 EXPECT_EQ(ret, nullptr);
172 }
173
174 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Query_Vibrate_test_001, TestSize.Level0)
175 {
176 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
177 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
178 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
179 EXPECT_EQ(mediaDataShare != nullptr, true);
180
181 Uri uri(VIBRATE_PATH_URI);
182 vector<string> columns;
183 const AbilityRuntime::DataSharePredicates predicates;
184 AbilityRuntime::DatashareBusinessError businessError;
185 auto ret = mediaDataShare->Query(uri, predicates, columns, businessError);
186 EXPECT_EQ(ret, nullptr);
187
188 Uri uriError(VIBRATE_URI_PATH);
189 ret = mediaDataShare->Query(uriError, predicates, columns, businessError);
190 EXPECT_EQ(ret, nullptr);
191 }
192
193 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_OpenFile_test_001, TestSize.Level0)
194 {
195 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
196 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
197 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
198 EXPECT_EQ(mediaDataShare != nullptr, true);
199
200 Uri uri(RINGTONE_PATH_URI);
201 auto ret = mediaDataShare->OpenFile(uri, RINGTONE_FILEMODE_READONLY);
202 EXPECT_EQ(ret, E_INVALID_VALUES);
203
204 Uri uriError(RINGTONE_URI);
205 ret = mediaDataShare->OpenFile(uriError, RINGTONE_FILEMODE_READONLY);
206 EXPECT_EQ(ret, E_INVALID_URI);
207 }
208
209 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_DumpDataShareValueBucket_test_001, TestSize.Level0)
210 {
211 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
212 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
213 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
214 EXPECT_EQ(mediaDataShare != nullptr, true);
215
216 const string ringtoneUintType = "uint_type";
217 const string ringtoneBoolType = "bool_type";
218 const string ringtoneDoubleType = "double_type";
219 const string ringtoneVectorType = "vector_type";
220 const int64_t addedTime = 1559276453;
221 const double doubleSize = 155.9276457;
222 std::vector<string> tabFields;
223 std::vector<uint8_t> ringtoneVec;
224 ringtoneVec.push_back(1);
225 tabFields.push_back(ringtoneUintType);
226 tabFields.push_back(RINGTONE_COLUMN_DATE_ADDED);
227 tabFields.push_back(RINGTONE_COLUMN_MIME_TYPE);
228 tabFields.push_back(ringtoneBoolType);
229 tabFields.push_back(ringtoneDoubleType);
230 tabFields.push_back(ringtoneVectorType);
231 AbilityRuntime::DataShareValuesBucket value;
232 value.Put(ringtoneUintType, static_cast<uint8_t>(1));
233 value.Put(RINGTONE_COLUMN_DATE_ADDED, static_cast<int64_t>(addedTime));
234 value.Put(RINGTONE_COLUMN_MIME_TYPE, static_cast<string>(RINGTONE_CONTAINER_TYPE_OGG));
235 value.Put(ringtoneBoolType, static_cast<bool>(true));
236 value.Put(ringtoneDoubleType, static_cast<double>(doubleSize));
237 value.Put(ringtoneVectorType, static_cast<std::vector<uint8_t>>(ringtoneVec));
238 mediaDataShare->DumpDataShareValueBucket(tabFields, value);
239 EXPECT_EQ(mediaDataShare != nullptr, true);
240 }
241
242 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_IdExists_test_001, TestSize.Level0)
243 {
244 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
245 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
246 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
247 EXPECT_NE(mediaDataShare, nullptr);
248
249 std::string ids = "";
250 int32_t id = 100;
251 bool ret = mediaDataShare->IdExists(ids, id);
252 EXPECT_FALSE(ret);
253
254 ids = "101";
255 id = 100;
256 ret = mediaDataShare->IdExists(ids, id);
257 EXPECT_FALSE(ret);
258
259 ids = "100 101";
260 id = 10;
261 ret = mediaDataShare->IdExists(ids, id);
262 EXPECT_FALSE(ret);
263
264 ids = "110 210";
265 id = 10;
266 ret = mediaDataShare->IdExists(ids, id);
267 EXPECT_FALSE(ret);
268
269 ids = "100 101";
270 id = 100;
271 ret = mediaDataShare->IdExists(ids, id);
272 EXPECT_TRUE(ret);
273 }
274
275 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_IdExists_test_002, TestSize.Level0)
276 {
277 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
278 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
279 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
280 EXPECT_NE(mediaDataShare, nullptr);
281
282 std::string ids = "100 101";
283 int32_t id = 101;
284 bool ret = mediaDataShare->IdExists(ids, id);
285 EXPECT_TRUE(ret);
286
287 ids = "100 101 102";
288 id = 102;
289 ret = mediaDataShare->IdExists(ids, id);
290 EXPECT_TRUE(ret);
291
292 ids = "100 101 102";
293 id = 101;
294 ret = mediaDataShare->IdExists(ids, id);
295 EXPECT_TRUE(ret);
296
297 ids = "100 101 102";
298 id = 100;
299 ret = mediaDataShare->IdExists(ids, id);
300 EXPECT_TRUE(ret);
301 }
302
303 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_GetUserId_test_001, TestSize.Level0)
304 {
305 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
306 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
307 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
308 EXPECT_NE(mediaDataShare, nullptr);
309
310 mediaDataShare->OnStop();
311 mediaDataShare->RingtoneScanner();
312 mediaDataShare->GetUserId();
313 auto ret1 = mediaDataShare->CheckCurrentUser();
314 EXPECT_EQ(ret1, true);
315 }
316
317 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_CheckRingtoneDbDefaultSettings_test_001, TestSize.Level0)
318 {
319 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
320 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
321 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
322 ASSERT_NE(mediaDataShare, nullptr);
323 int errCode = 0;
324 shared_ptr<NativePreferences::Preferences> prefs =
325 NativePreferences::PreferencesHelper::GetPreferences(COMMON_XML_EL1, errCode);
326 ASSERT_NE(prefs, nullptr);
327 prefs->PutInt(RINGTONE_RDB_SCANNER_FLAG_KEY, RINGTONE_RDB_SCANNER_FLAG_KEY_FALSE);
328 prefs->FlushSync();
329
330 auto dataManager = RingtoneDataManager::GetInstance();
331 ASSERT_NE(dataManager, nullptr);
332 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
333 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
334 ASSERT_NE(abilityContextImpl, nullptr);
335 abilityContextImpl->SetStageContext(stageContext);
336 auto result = dataManager->Init(abilityContextImpl);
337 EXPECT_EQ(result, E_OK);
338 shared_ptr<RingtoneUnistore> uniStore = RingtoneRdbStore::GetInstance();
339 ASSERT_NE(uniStore, nullptr);
340 auto rawRdb = uniStore->GetRaw();
341 ASSERT_NE(rawRdb, nullptr);
342 NativeRdb::ValuesBucket values;
343 values.PutString(PRELOAD_CONFIG_COLUMN_DISPLAY_NAME, "Harmony.ogg");
344 values.PutInt(PRELOAD_CONFIG_COLUMN_TONE_ID, 1);
345 NativeRdb::AbsRdbPredicates absRdbPredicates(PRELOAD_CONFIG_TABLE);
346 absRdbPredicates.EqualTo(PRELOAD_CONFIG_COLUMN_RING_TONE_TYPE, "1");
347
348 int32_t changedRows = 0;
349 int32_t updateResult = rawRdb->Update(changedRows, values, absRdbPredicates);
350 EXPECT_EQ(updateResult == E_OK && changedRows >= 0, true);
351
352 mediaDataShare->CheckRingtoneDbDefaultSettings();
353 int isScanner = prefs->GetInt(RINGTONE_RDB_SCANNER_FLAG_KEY, RINGTONE_RDB_SCANNER_FLAG_KEY_FALSE);
354 EXPECT_EQ(isScanner, RINGTONE_RDB_SCANNER_FLAG_KEY_TRUE);
355 }
356 } // namespace Media
357 } // namespace OHOS
358