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_handler.h"
19 #include "ability_info.h"
20 #include "datashare_ext_ability.h"
21 #include "get_self_permissions.h"
22 #include "ohos_application.h"
23 #define private public
24 #include "ringtone_datashare_stub_impl.h"
25 #undef private
26 #include "ringtone_db_const.h"
27 #include "ringtone_errno.h"
28 #include "ringtone_file_utils.h"
29 #include "ringtone_type.h"
30 #include "runtime.h"
31
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace Media {
39
SetUpTestCase()40 void RingtoneDataShareExtensionTest::SetUpTestCase()
41 {
42 vector<string> perms;
43 perms.push_back("ohos.permission.WRITE_RINGTONE");
44
45 uint64_t tokenId = 0;
46 RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneDataManagerUnitTest", perms, tokenId);
47 ASSERT_TRUE(tokenId != 0);
48 }
TearDownTestCase()49 void RingtoneDataShareExtensionTest::TearDownTestCase() {}
50
51 // SetUp:Execute before each test case
SetUp()52 void RingtoneDataShareExtensionTest::SetUp() {}
53
TearDown()54 void RingtoneDataShareExtensionTest::TearDown() {}
55
56 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_OnConnect_test_001, TestSize.Level0)
57 {
58 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
59 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
60 AbilityRuntime::DataShareExtAbility::Create(runtime);
61 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
62 ASSERT_TRUE(mediaDataShare != nullptr);
63
64 std::shared_ptr<AppExecFwk::AbilityLocalRecord> record = nullptr;
65 const std::shared_ptr<AppExecFwk::OHOSApplication> application = nullptr;
66 std::shared_ptr<AppExecFwk::AbilityHandler> handler = nullptr;
67 const sptr<IRemoteObject> token = nullptr;
68 mediaDataShare->Init(record, application, handler, token);
69
70 std::shared_ptr<AbilityRuntime::AbilityInfo> info = std::make_shared<AbilityRuntime::AbilityInfo>();
71 info->name = "start";
72 napi_env env = nullptr;
73 shared_ptr<DataShare::RingtoneDataShareExtension> extension(mediaDataShare);
74 sptr<DataShare::RingtoneDataShareStubImpl> remoteObject =
75 new DataShare::RingtoneDataShareStubImpl(extension, env);
76 auto recordTwo = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, token, nullptr, 0);
77 mediaDataShare->Init(recordTwo, application, handler, token);
78 std::shared_ptr<AppExecFwk::OHOSApplication> applicationTwo = std::make_shared<AppExecFwk::OHOSApplication>();
79 mediaDataShare->Init(recordTwo, applicationTwo, handler, token);
80 std::shared_ptr<AbilityRuntime::EventRunner> runner = nullptr;
81 std::shared_ptr<AppExecFwk::AbilityHandler> handlerTwo = make_shared<AppExecFwk::AbilityHandler>(runner);
82 mediaDataShare->Init(recordTwo, applicationTwo, handlerTwo, token);
83 const sptr<IRemoteObject> tokenTwo = remoteObject->AsObject();
84 mediaDataShare->Init(recordTwo, applicationTwo, handlerTwo, tokenTwo);
85 AAFwk::Want want;
86 auto ret = mediaDataShare->OnConnect(want);
87 EXPECT_EQ((ret != nullptr), true);
88 mediaDataShare->OnStart(want);
89 mediaDataShare->OnStop();
90 ret = mediaDataShare->OnConnect(want);
91 EXPECT_EQ((ret != nullptr), true);
92 }
93
94 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Update_test_001, TestSize.Level0)
95 {
96 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
97 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
98 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
99 EXPECT_EQ(mediaDataShare != nullptr, true);
100
101 Uri uri(RINGTONE_PATH_URI);
102 const AbilityRuntime::DataSharePredicates predicates;
103 AbilityRuntime::DataShareValuesBucket values;
104 auto ret = mediaDataShare->Update(uri, predicates, values);
105 EXPECT_EQ(ret, E_COMMON_START);
106
107 Uri uriError(RINGTONE_URI);
108 ret = mediaDataShare->Update(uriError, predicates, values);
109 EXPECT_EQ(ret, E_INVALID_URI);
110 }
111
112 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Query_test_001, TestSize.Level0)
113 {
114 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
115 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
116 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
117 EXPECT_EQ(mediaDataShare != nullptr, true);
118
119 Uri uri(RINGTONE_PATH_URI);
120 vector<string> columns;
121 const AbilityRuntime::DataSharePredicates predicates;
122 AbilityRuntime::DatashareBusinessError businessError;
123 auto ret = mediaDataShare->Query(uri, predicates, columns, businessError);
124 EXPECT_EQ(ret, nullptr);
125
126 Uri uriError(RINGTONE_URI);
127 ret = mediaDataShare->Query(uriError, predicates, columns, businessError);
128 EXPECT_EQ(ret, nullptr);
129 }
130
131 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Query_Vibrate_test_001, TestSize.Level0)
132 {
133 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
134 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
135 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
136 EXPECT_EQ(mediaDataShare != nullptr, true);
137
138 Uri uri(VIBRATE_PATH_URI);
139 vector<string> columns;
140 const AbilityRuntime::DataSharePredicates predicates;
141 AbilityRuntime::DatashareBusinessError businessError;
142 auto ret = mediaDataShare->Query(uri, predicates, columns, businessError);
143 EXPECT_EQ(ret, nullptr);
144
145 Uri uriError(VIBRATE_URI_PATH);
146 ret = mediaDataShare->Query(uriError, predicates, columns, businessError);
147 EXPECT_EQ(ret, nullptr);
148 }
149
150 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_DumpDataShareValueBucket_test_001, TestSize.Level0)
151 {
152 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
153 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
154 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
155 EXPECT_EQ(mediaDataShare != nullptr, true);
156
157 const string ringtoneUintType = "uint_type";
158 const string ringtoneBoolType = "bool_type";
159 const string ringtoneDoubleType = "double_type";
160 const string ringtoneVectorType = "vector_type";
161 const int64_t addedTime = 1559276453;
162 const double doubleSize = 155.9276457;
163 std::vector<string> tabFields;
164 std::vector<uint8_t> ringtoneVec;
165 ringtoneVec.push_back(1);
166 tabFields.push_back(ringtoneUintType);
167 tabFields.push_back(RINGTONE_COLUMN_DATE_ADDED);
168 tabFields.push_back(RINGTONE_COLUMN_MIME_TYPE);
169 tabFields.push_back(ringtoneBoolType);
170 tabFields.push_back(ringtoneDoubleType);
171 tabFields.push_back(ringtoneVectorType);
172 AbilityRuntime::DataShareValuesBucket value;
173 value.Put(ringtoneUintType, static_cast<uint8_t>(1));
174 value.Put(RINGTONE_COLUMN_DATE_ADDED, static_cast<int64_t>(addedTime));
175 value.Put(RINGTONE_COLUMN_MIME_TYPE, static_cast<string>(RINGTONE_CONTAINER_TYPE_OGG));
176 value.Put(ringtoneBoolType, static_cast<bool>(true));
177 value.Put(ringtoneDoubleType, static_cast<double>(doubleSize));
178 value.Put(ringtoneVectorType, static_cast<std::vector<uint8_t>>(ringtoneVec));
179 mediaDataShare->DumpDataShareValueBucket(tabFields, value);
180 EXPECT_EQ(mediaDataShare != nullptr, true);
181 }
182
183 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_IdExists_test_001, TestSize.Level0)
184 {
185 const std::unique_ptr<AbilityRuntime::Runtime> runtime;
186 AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
187 mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
188 EXPECT_NE(mediaDataShare, nullptr);
189
190 std::string ids = "";
191 int32_t id = 100;
192 bool ret = mediaDataShare->IdExists(ids, id);
193 EXPECT_FALSE(ret);
194
195 ids = "101";
196 id = 100;
197 ret = mediaDataShare->IdExists(ids, id);
198 EXPECT_FALSE(ret);
199
200 ids = "100 101";
201 id = 10;
202 ret = mediaDataShare->IdExists(ids, id);
203 EXPECT_FALSE(ret);
204
205 ids = "110 210";
206 id = 10;
207 ret = mediaDataShare->IdExists(ids, id);
208 EXPECT_FALSE(ret);
209
210 ids = "100 101";
211 id = 100;
212 ret = mediaDataShare->IdExists(ids, id);
213 EXPECT_TRUE(ret);
214 }
215 } // namespace Media
216 } // namespace OHOS
217