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 #define LOG_TAG "DataShareServiceImplTest"
16 
17 #include <gtest/gtest.h>
18 #include <unistd.h>
19 #include "log_print.h"
20 #include "ipc_skeleton.h"
21 #include "data_share_service_stub.h"
22 #include "dump/dump_manager.h"
23 #include "accesstoken_kit.h"
24 #include "hap_token_info.h"
25 #include "iservice_registry.h"
26 #include "system_ability_definition.h"
27 #include "token_setproc.h"
28 #include "data_share_service_impl.h"
29 
30 using namespace testing::ext;
31 using namespace OHOS::DataShare;
32 using namespace OHOS::DistributedData;
33 using namespace OHOS::Security::AccessToken;
34 std::string SLIENT_ACCESS_URI = "datashareproxy://com.acts.ohos.data.datasharetest/test";
35 std::string TBL_NAME0 = "name0";
36 std::string TBL_NAME1 = "name1";
37 std::string  BUNDLE_NAME = "ohos.datasharetest.demo";
38 namespace OHOS::Test {
39 class DataShareServiceImplTest : public testing::Test {
40 public:
41     static constexpr int64_t USER_TEST = 100;
42     static constexpr int64_t TEST_SUB_ID = 100;
43     static constexpr uint32_t CUREEENT_USER_ID = 123;
SetUpTestCase(void)44     static void SetUpTestCase(void){};
TearDownTestCase(void)45     static void TearDownTestCase(void){};
46     void SetUp();
47     void TearDown();
48 };
49 
SetUp(void)50 void DataShareServiceImplTest::SetUp(void)
51 {
52     HapInfoParams info = {
53         .userID = USER_TEST,
54         .bundleName = "ohos.datasharetest.demo",
55         .instIndex = 0,
56         .appIDDesc = "ohos.datasharetest.demo"
57     };
58     HapPolicyParams policy = {
59         .apl = APL_NORMAL,
60         .domain = "test.domain",
61         .permList = {
62             {
63                 .permissionName = "ohos.permission.test",
64                 .bundleName = "ohos.datasharetest.demo",
65                 .grantMode = 1,
66                 .availableLevel = APL_NORMAL,
67                 .label = "label",
68                 .labelId = 1,
69                 .description = "ohos.datasharetest.demo",
70                 .descriptionId = 1
71             }
72         },
73         .permStateList = {
74             {
75                 .permissionName = "ohos.permission.test",
76                 .isGeneral = true,
77                 .resDeviceID = { "local" },
78                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
79                 .grantFlags = { 1 }
80             }
81         }
82     };
83     AccessTokenKit::AllocHapToken(info, policy);
84     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenID(
85         info.userID, info.bundleName, info.instIndex);
86     SetSelfTokenID(testTokenId);
87 }
88 
TearDown(void)89 void DataShareServiceImplTest::TearDown(void)
90 {
91     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
92     AccessTokenKit::DeleteToken(tokenId);
93 }
94 
95 /**
96 * @tc.name: DataShareServiceImpl001
97 * @tc.desc: test InsertEx UpdateEx Query DeleteEx abnormal scene
98 * @tc.type: FUNC
99 * @tc.require:SQL
100 */
101 HWTEST_F(DataShareServiceImplTest, DataShareServiceImpl001, TestSize.Level1)
102 {
103     DataShareServiceImpl dataShareServiceImpl;
104     std::string uri = "";
105     bool enable = true;
106     auto resultA = dataShareServiceImpl.EnableSilentProxy(uri, enable);
107     EXPECT_EQ(resultA, DataShare::E_OK);
108 
109     DataShare::DataShareValuesBucket valuesBucket;
110     std::string name0 = "";
111     valuesBucket.Put("", name0);
112     auto [errCode, result] = dataShareServiceImpl.InsertEx(uri, "", valuesBucket);
113     EXPECT_EQ((errCode != 0), true);
114 
115     DataShare::DataSharePredicates predicates;
116     std::string selections = "";
117     predicates.SetWhereClause(selections);
118     auto [errCode1, result1] = dataShareServiceImpl.UpdateEx(uri, "", predicates, valuesBucket);
119     EXPECT_EQ((errCode1 != 0), true);
120 
121     predicates.EqualTo("", "");
122     std::vector<std::string> columns;
123     int errVal = 0;
124     auto resQuery = dataShareServiceImpl.Query(uri, "", predicates, columns, errVal);
125     int resultSet = 0;
126     if (resQuery != nullptr) {
127         resQuery->GetRowCount(resultSet);
128     }
129     EXPECT_EQ(resultSet, 0);
130 
131     predicates.SetWhereClause(selections);
132     auto [errCode2, result2] = dataShareServiceImpl.DeleteEx(uri, "", predicates);
133     EXPECT_EQ((errCode2 != 0), true);
134 }
135 
136 /**
137 * @tc.name: DataShareServiceImpl002
138 * @tc.desc: test Insert Update Query Delete abnormal scene
139 * @tc.type: FUNC
140 * @tc.require:SQL
141 */
142 HWTEST_F(DataShareServiceImplTest, DataShareServiceImpl002, TestSize.Level1)
143 {
144     DataShareServiceImpl dataShareServiceImpl;
145     std::string uri = "";
146     bool enable = true;
147     auto resultA = dataShareServiceImpl.EnableSilentProxy(uri, enable);
148     EXPECT_EQ(resultA, DataShare::E_OK);
149 
150     DataShare::DataShareValuesBucket valuesBucket;
151     std::string name0 = "";
152     valuesBucket.Put("", name0);
153     auto result = dataShareServiceImpl.Insert(uri, valuesBucket);
154     EXPECT_EQ((result > 0), true);
155 
156     DataShare::DataSharePredicates predicates;
157     std::string selections = "";
158     predicates.SetWhereClause(selections);
159     result = dataShareServiceImpl.Update(uri, predicates, valuesBucket);
160     EXPECT_EQ((result > 0), true);
161 
162     predicates.EqualTo("", "");
163     std::vector<std::string> columns;
164     int errCode = 0;
165     auto resQuery = dataShareServiceImpl.Query(uri, "", predicates, columns, errCode);
166     int resultSet = 0;
167     if (resQuery != nullptr) {
168         resQuery->GetRowCount(resultSet);
169     }
170     EXPECT_EQ(resultSet, 0);
171 
172     predicates.SetWhereClause(selections);
173     result = dataShareServiceImpl.Delete(uri, predicates);
174     EXPECT_EQ((result > 0), true);
175 }
176 
177 /**
178 * @tc.name: NotifyChange001
179 * @tc.desc: test NotifyChange function and abnormal scene
180 * @tc.type: FUNC
181 * @tc.require:SQL
182 */
183 HWTEST_F(DataShareServiceImplTest, NotifyChange001, TestSize.Level1)
184 {
185     DataShareServiceImpl dataShareServiceImpl;
186     std::string uri = SLIENT_ACCESS_URI;
187     auto result = dataShareServiceImpl.NotifyChange(uri);
188     EXPECT_EQ(result, true);
189 
190     result = dataShareServiceImpl.NotifyChange("");
191     EXPECT_EQ(result, false);
192 }
193 
194 /**
195 * @tc.name: AddTemplate001
196 * @tc.desc: test AddTemplate function and abnormal scene
197 * @tc.type: FUNC
198 * @tc.require:SQL
199 */
200 HWTEST_F(DataShareServiceImplTest, AddTemplate001, TestSize.Level1)
201 {
202     DataShareServiceImpl dataShareServiceImpl;
203     std::string uri = SLIENT_ACCESS_URI;
204     int64_t subscriberId = 0;
205     PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
206     PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
207     std::vector<PredicateTemplateNode> nodes;
208     nodes.emplace_back(node1);
209     nodes.emplace_back(node2);
210     Template tpl(nodes, "select name1 as name from TBL00");
211 
212     auto result = dataShareServiceImpl.AddTemplate(uri, subscriberId, tpl);
213     EXPECT_EQ((result > 0), true);
214     result = dataShareServiceImpl.DelTemplate(uri, subscriberId);
215     EXPECT_EQ((result > 0), true);
216 
217     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
218     AccessTokenKit::DeleteToken(tokenId);
219     result = dataShareServiceImpl.AddTemplate(uri, subscriberId, tpl);
220     EXPECT_EQ(result, DataShareServiceImpl::ERROR);
221     result = dataShareServiceImpl.DelTemplate(uri, subscriberId);
222     EXPECT_EQ(result, DataShareServiceImpl::ERROR);
223 }
224 
225 /**
226 * @tc.name: GetCallerBundleName001
227 * @tc.desc: test GetCallerBundleName function and abnormal scene
228 * @tc.type: FUNC
229 * @tc.require:SQL
230 */
231 HWTEST_F(DataShareServiceImplTest, GetCallerBundleName001, TestSize.Level1)
232 {
233     DataShareServiceImpl dataShareServiceImpl;
234     auto result = dataShareServiceImpl.GetCallerBundleName(BUNDLE_NAME);
235     EXPECT_EQ(result, true);
236 
237     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
238     AccessTokenKit::DeleteToken(tokenId);
239     result = dataShareServiceImpl.GetCallerBundleName(BUNDLE_NAME);
240     EXPECT_EQ(result, false);
241 }
242 
243 /**
244 * @tc.name: Publish001
245 * @tc.desc: test Publish and GetData no GetCallerBundleName scene
246 * @tc.type: FUNC
247 * @tc.require:SQL
248 */
249 HWTEST_F(DataShareServiceImplTest, Publish001, TestSize.Level1)
250 {
251     DataShareServiceImpl dataShareServiceImpl;
252     DataShare::Data data;
253     std::string bundleName = "com.acts.ohos.data.datasharetest";
254     data.datas_.emplace_back("datashareproxy://com.acts.ohos.data.datasharetest/test", TEST_SUB_ID, "value1");
255     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
256     AccessTokenKit::DeleteToken(tokenId);
257     std::vector<OperationResult> result = dataShareServiceImpl.Publish(data, bundleName);
258     EXPECT_NE(result.size(), data.datas_.size());
259     for (auto const &results : result) {
260         EXPECT_NE(results.errCode_, 0);
261     }
262 
263     int errCode = 0;
264     auto getData = dataShareServiceImpl.GetData(bundleName, errCode);
265     EXPECT_EQ(errCode, 0);
266     EXPECT_NE(getData.datas_.size(), data.datas_.size());
267 }
268 
269 /**
270 * @tc.name: Publish002
271 * @tc.desc: test Publish uri and GetData bundleName is error
272 * @tc.type: FUNC
273 * @tc.require:SQL
274 */
275 HWTEST_F(DataShareServiceImplTest, Publish002, TestSize.Level1)
276 {
277     DataShareServiceImpl dataShareServiceImpl;
278     DataShare::Data data;
279     std::string bundleName = "com.acts.ohos.error";
280     data.datas_.emplace_back("datashareproxy://com.acts.ohos.error", TEST_SUB_ID, "value1");
281     std::vector<OperationResult> result = dataShareServiceImpl.Publish(data, bundleName);
282     EXPECT_EQ(result.size(), data.datas_.size());
283     for (auto const &results : result) {
284         EXPECT_EQ(results.errCode_, E_URI_NOT_EXIST);
285     }
286 
287     int errCode = 0;
288     auto getData = dataShareServiceImpl.GetData(bundleName, errCode);
289     EXPECT_EQ(errCode, 0);
290     EXPECT_NE(getData.datas_.size(), data.datas_.size());
291 }
292 
293 /**
294 * @tc.name: SubscribeRdbData001
295 * @tc.desc: Tests the operation of a subscription to a data change of the specified URI
296 * @tc.type: FUNC
297 * @tc.require:SQL
298 */
299 HWTEST_F(DataShareServiceImplTest, SubscribeRdbData001, TestSize.Level1)
300 {
301     DataShareServiceImpl dataShareServiceImpl;
302     PredicateTemplateNode node("p1", "select name0 as name from TBL00");
303     std::vector<PredicateTemplateNode> nodes;
304     nodes.emplace_back(node);
305     Template tpl(nodes, "select name1 as name from TBL00");
306     auto result1 = dataShareServiceImpl.AddTemplate(SLIENT_ACCESS_URI, TEST_SUB_ID, tpl);
307     EXPECT_TRUE(result1);
308     std::vector<std::string> uris;
309     uris.emplace_back(SLIENT_ACCESS_URI);
310     sptr<IDataProxyRdbObserver> observer;
311     TemplateId tplId;
312     tplId.subscriberId_ = TEST_SUB_ID;
313     tplId.bundleName_ = BUNDLE_NAME;
314     std::vector<OperationResult> result2 = dataShareServiceImpl.SubscribeRdbData(uris, tplId, observer);
315     EXPECT_EQ(result2.size(), uris.size());
316     for (auto const &operationResult : result2) {
317         EXPECT_NE(operationResult.errCode_, 0);
318     }
319 
320     std::vector<OperationResult> result3 = dataShareServiceImpl.EnableRdbSubs(uris, tplId);
321     for (auto const &operationResult : result3) {
322         EXPECT_NE(operationResult.errCode_, 0);
323     }
324 
325     std::string uri = SLIENT_ACCESS_URI;
326     DataShare::DataShareValuesBucket valuesBucket1, valuesBucket2;
327     std::string name0 = "wang";
328     valuesBucket1.Put(TBL_NAME0, name0);
329     auto result4 = dataShareServiceImpl.Insert(uri, valuesBucket1);
330     EXPECT_EQ((result4 > 0), true);
331 
332     std::vector<OperationResult> result5 = dataShareServiceImpl.UnsubscribeRdbData(uris, tplId);
333     EXPECT_EQ(result5.size(), uris.size());
334     for (auto const &operationResult : result5) {
335         EXPECT_NE(operationResult.errCode_, 0);
336     }
337 
338     std::string name1 = "wu";
339     valuesBucket2.Put(TBL_NAME1, name1);
340     auto result6 = dataShareServiceImpl.Insert(uri, valuesBucket2);
341     EXPECT_EQ((result6 > 0), true);
342 
343     std::vector<OperationResult> result7 = dataShareServiceImpl.DisableRdbSubs(uris, tplId);
344     for (auto const &operationResult : result7) {
345         EXPECT_NE(operationResult.errCode_, 0);
346     }
347 }
348 
349 /**
350 * @tc.name: SubscribePublishedData001
351 * @tc.desc: test SubscribePublishedData no GetCallerBundleName scene
352 * @tc.type: FUNC
353 * @tc.require:SQL
354 */
355 HWTEST_F(DataShareServiceImplTest, SubscribePublishedData001, TestSize.Level1)
356 {
357     DataShareServiceImpl dataShareServiceImpl;
358     std::vector<std::string> uris;
359     uris.emplace_back(SLIENT_ACCESS_URI);
360     sptr<IDataProxyPublishedDataObserver> observer;
361     int64_t subscriberId = TEST_SUB_ID;
362 
363     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
364     AccessTokenKit::DeleteToken(tokenId);
365     std::vector<OperationResult> result =  dataShareServiceImpl.SubscribePublishedData(uris, subscriberId, observer);
366     EXPECT_NE(result.size(), uris.size());
367     for (auto const &operationResult : result) {
368         EXPECT_EQ(operationResult.errCode_, 0);
369     }
370 
371     result =  dataShareServiceImpl.UnsubscribePublishedData(uris, subscriberId);
372     EXPECT_NE(result.size(), uris.size());
373     for (auto const &operationResult : result) {
374         EXPECT_EQ(operationResult.errCode_, 0);
375     }
376 }
377 
378 /**
379 * @tc.name: SubscribePublishedData002
380 * @tc.desc: test SubscribePublishedData abnormal scene
381 * @tc.type: FUNC
382 * @tc.require:SQL
383 */
384 HWTEST_F(DataShareServiceImplTest, SubscribePublishedData002, TestSize.Level1)
385 {
386     DataShareServiceImpl dataShareServiceImpl;
387     std::vector<std::string> uris;
388     uris.emplace_back("");
389     sptr<IDataProxyPublishedDataObserver> observer;
390     int64_t subscriberId = 0;
391     std::vector<OperationResult> result = dataShareServiceImpl.SubscribePublishedData(uris, subscriberId, observer);
392     EXPECT_EQ(result.size(), uris.size());
393     for (auto const &operationResult : result) {
394         EXPECT_NE(operationResult.errCode_, 0);
395     }
396 
397     result = dataShareServiceImpl.UnsubscribePublishedData(uris, subscriberId);
398     EXPECT_EQ(result.size(), uris.size());
399     for (auto const &operationResult : result) {
400         EXPECT_NE(operationResult.errCode_, 0);
401     }
402 }
403 
404 /**
405 * @tc.name: EnablePubSubs001
406 * @tc.desc: test EnablePubSubs no GetCallerBundleName scene
407 * @tc.type: FUNC
408 * @tc.require:SQL
409 */
410 HWTEST_F(DataShareServiceImplTest, EnablePubSubs001, TestSize.Level1)
411 {
412     DataShareServiceImpl dataShareServiceImpl;
413     std::vector<std::string> uris;
414     uris.emplace_back(SLIENT_ACCESS_URI);
415     int64_t subscriberId = TEST_SUB_ID;
416 
417     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
418     AccessTokenKit::DeleteToken(tokenId);
419     dataShareServiceImpl.OnConnectDone();
420     std::vector<OperationResult> result = dataShareServiceImpl.EnablePubSubs(uris, subscriberId);
421     for (auto const &operationResult : result) {
422         EXPECT_EQ(operationResult.errCode_, 0);
423     }
424 
425     result = dataShareServiceImpl.DisablePubSubs(uris, subscriberId);
426     for (auto const &operationResult : result) {
427         EXPECT_EQ(operationResult.errCode_, 0);
428     }
429 }
430 
431 /**
432 * @tc.name: EnablePubSubs002
433 * @tc.desc: test EnablePubSubs abnormal scene
434 * @tc.type: FUNC
435 * @tc.require:SQL
436 */
437 HWTEST_F(DataShareServiceImplTest, EnablePubSubs002, TestSize.Level1)
438 {
439     DataShareServiceImpl dataShareServiceImpl;
440     std::vector<std::string> uris;
441     uris.emplace_back("");
442     int64_t subscriberId = 0;
443     std::vector<OperationResult> result = dataShareServiceImpl.EnablePubSubs(uris, subscriberId);
444     for (auto const &operationResult : result) {
445         EXPECT_NE(operationResult.errCode_, 0);
446     }
447 
448     result = dataShareServiceImpl.DisablePubSubs(uris, subscriberId);
449     for (auto const &operationResult : result) {
450         EXPECT_NE(operationResult.errCode_, 0);
451     }
452 }
453 
454 /**
455 * @tc.name: OnAppUninstall
456 * @tc.desc: Test the operation of the app
457 * @tc.type: FUNC
458 * @tc.require:SQL
459 */
460 HWTEST_F(DataShareServiceImplTest, OnAppUninstall, TestSize.Level1)
461 {
462     DataShareServiceImpl dataShareServiceImpl;
463     pid_t uid = 1;
464     pid_t pid = 2;
465     int32_t user = USER_TEST;
466     int32_t index = 0;
467     uint32_t tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, BUNDLE_NAME, 0);
468 
469     auto result = dataShareServiceImpl.OnAppUpdate(BUNDLE_NAME, user, index);
470     EXPECT_EQ(result, GeneralError::E_OK);
471 
472     result = dataShareServiceImpl.OnAppExit(uid, pid, tokenId, BUNDLE_NAME);
473     EXPECT_EQ(result, GeneralError::E_OK);
474 
475     result = dataShareServiceImpl.OnAppUninstall(BUNDLE_NAME, user, index);
476     EXPECT_EQ(result, GeneralError::E_OK);
477 
478     DataShareServiceImpl::DataShareStatic dataShareStatic;
479     result = dataShareStatic.OnAppUninstall(BUNDLE_NAME, user, index);
480     EXPECT_EQ(result, GeneralError::E_OK);
481 }
482 
483 /**
484 * @tc.name: OnInitialize
485 * @tc.desc: test OnInitialize function
486 * @tc.type: FUNC
487 * @tc.require:SQL
488 */
489 HWTEST_F(DataShareServiceImplTest, OnInitialize, TestSize.Level1)
490 {
491     DataShareServiceImpl dataShareServiceImpl;
492     int fd = 1;
493     std::map<std::string, std::vector<std::string>> params;
494     dataShareServiceImpl.DumpDataShareServiceInfo(fd, params);
495     auto result = dataShareServiceImpl.OnInitialize();
496     EXPECT_EQ(result, 0);
497 }
498 
499 /**
500 * @tc.name: NotifyObserver
501 * @tc.desc: test NotifyObserver no GetCallerBundleName scene
502 * @tc.type: FUNC
503 * @tc.require:SQL
504 */
505 HWTEST_F(DataShareServiceImplTest, NotifyObserver, TestSize.Level1)
506 {
507     DataShareServiceImpl dataShareServiceImpl;
508     std::string uri = SLIENT_ACCESS_URI;
509     sptr<OHOS::IRemoteObject> remoteObj;
510     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.datasharetest.demo", 0);
511     AccessTokenKit::DeleteToken(tokenId);
512 
513     auto result = dataShareServiceImpl.RegisterObserver(uri, remoteObj);
514     EXPECT_EQ(result, ERR_INVALID_VALUE);
515     dataShareServiceImpl.NotifyObserver(uri);
516     result = dataShareServiceImpl.UnregisterObserver(uri, remoteObj);
517     EXPECT_EQ(result, ERR_INVALID_VALUE);
518 }
519 
520 /**
521 * @tc.name: RegisterObserver
522 * @tc.desc: test RegisterObserver abnormal scene
523 * @tc.type: FUNC
524 * @tc.require:SQL
525 */
526 HWTEST_F(DataShareServiceImplTest, RegisterObserver, TestSize.Level1)
527 {
528     DataShareServiceImpl dataShareServiceImpl;
529     sptr<OHOS::IRemoteObject> remoteObj;
530     auto result = dataShareServiceImpl.RegisterObserver("", remoteObj);
531     EXPECT_EQ(result, ERR_INVALID_VALUE);
532     dataShareServiceImpl.NotifyObserver("");
533     result = dataShareServiceImpl.UnregisterObserver("", remoteObj);
534     EXPECT_EQ(result, ERR_INVALID_VALUE);
535 }
536 } // namespace OHOS::Test