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 "DataShareSubscriberManagersTest"
16 
17 #include <gtest/gtest.h>
18 #include <unistd.h>
19 
20 #include "accesstoken_kit.h"
21 #include "datashare_errno.h"
22 #include "data_share_service_impl.h"
23 #include "hap_token_info.h"
24 #include "ipc_skeleton.h"
25 #include "iservice_registry.h"
26 #include "log_print.h"
27 #include "published_data_subscriber_manager.h"
28 #include "rdb_subscriber_manager.h"
29 #include "system_ability_definition.h"
30 #include "token_setproc.h"
31 
32 using namespace testing::ext;
33 using namespace OHOS::DataShare;
34 using namespace OHOS::DistributedData;
35 using namespace OHOS::Security::AccessToken;
36 std::string DATA_SHARE_URI_TEST = "datashare://com.acts.ohos.data.subscribermanagertest/test";
37 std::string BUNDLE_NAME_TEST = "ohos.subscribermanagertest.demo";
38 namespace OHOS::Test {
39 class DataShareSubscriberManagersTest : public testing::Test {
40 public:
41     static constexpr int64_t USER_TEST = 100;
42     static constexpr int64_t TEST_SUB_ID = 100;
43     static void SetUpTestCase(void);
44     static void TearDownTestCase(void);
SetUp()45     void SetUp(){};
TearDown()46     void TearDown(){};
47 };
48 
SetUpTestCase(void)49 void DataShareSubscriberManagersTest::SetUpTestCase(void)
50 {
51     HapInfoParams info = {
52         .userID = USER_TEST,
53         .bundleName = "ohos.subscribermanagertest.demo",
54         .instIndex = 0,
55         .appIDDesc = "ohos.subscribermanagertest.demo"
56     };
57     HapPolicyParams policy = {
58         .apl = APL_NORMAL,
59         .domain = "test.domain",
60         .permList = {
61             {
62                 .permissionName = "ohos.permission.test",
63                 .bundleName = "ohos.subscribermanagertest.demo",
64                 .grantMode = 1,
65                 .availableLevel = APL_NORMAL,
66                 .label = "label",
67                 .labelId = 1,
68                 .description = "ohos.subscribermanagertest.demo",
69                 .descriptionId = 1
70             }
71         },
72         .permStateList = {
73             {
74                 .permissionName = "ohos.permission.test",
75                 .isGeneral = true,
76                 .resDeviceID = { "local" },
77                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
78                 .grantFlags = { 1 }
79             }
80         }
81     };
82     AccessTokenKit::AllocHapToken(info, policy);
83     auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenID(
84         info.userID, info.bundleName, info.instIndex);
85     SetSelfTokenID(testTokenId);
86 }
87 
TearDownTestCase(void)88 void DataShareSubscriberManagersTest::TearDownTestCase(void)
89 {
90     auto tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, "ohos.subscribermanagertest.demo", 0);
91     AccessTokenKit::DeleteToken(tokenId);
92 }
93 
94 /**
95 * @tc.name: Add
96 * @tc.desc: test add and delete abnormal case
97 * @tc.type: FUNC
98 * @tc.require:SQL
99 */
100 HWTEST_F(DataShareSubscriberManagersTest, Add, TestSize.Level1)
101 {
102     auto context = std::make_shared<Context>(DATA_SHARE_URI_TEST);
103     TemplateId tpltId;
104     tpltId.subscriberId_ = TEST_SUB_ID;
105     tpltId.bundleName_ = BUNDLE_NAME_TEST;
106     PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
107     PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
108     std::vector<PredicateTemplateNode> nodes;
109     nodes.emplace_back(node1);
110     nodes.emplace_back(node2);
111     Template tpl(nodes, "select name1 as name from TBL00");
112     DataShare::Key key(DATA_SHARE_URI_TEST, tpltId.subscriberId_, tpltId.bundleName_);
113     auto result = TemplateManager::GetInstance().Add(key, context->currentUserId, tpl);
114     EXPECT_EQ(result, DataShare::E_ERROR);
115     result = TemplateManager::GetInstance().Delete(key, context->currentUserId);
116     EXPECT_EQ(result, DataShare::E_ERROR);
117 }
118 
119 /**
120 * @tc.name: Key
121 * @tc.desc: test Key operator< subscriberId function
122 * @tc.type: FUNC
123 * @tc.require:SQL
124 */
125 HWTEST_F(DataShareSubscriberManagersTest, Key, TestSize.Level1)
126 {
127     DataShare::Key key1(DATA_SHARE_URI_TEST, TEST_SUB_ID, BUNDLE_NAME_TEST);
128     DataShare::Key key2(DATA_SHARE_URI_TEST, 0, BUNDLE_NAME_TEST);
129 
130     EXPECT_FALSE(key1 < key2);
131     EXPECT_TRUE(key2 < key1);
132 }
133 
134 /**
135 * @tc.name: Delete
136 * @tc.desc: test Delete abnormal case
137 * @tc.type: FUNC
138 * @tc.require:SQL
139 */
140 HWTEST_F(DataShareSubscriberManagersTest, Delete, TestSize.Level1)
141 {
142     auto context = std::make_shared<Context>(DATA_SHARE_URI_TEST);
143     DataShare::Key key(context->uri, TEST_SUB_ID, BUNDLE_NAME_TEST);
144     uint32_t tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, BUNDLE_NAME_TEST, USER_TEST);
145     uint32_t pid = getpid();
146     RdbSubscriberManager::GetInstance().Delete(tokenId, pid);
147     auto result = RdbSubscriberManager::GetInstance().Delete(key, tokenId);
148     EXPECT_EQ(result, E_SUBSCRIBER_NOT_EXIST);
149 }
150 
151 /**
152 * @tc.name: Disable
153 * @tc.desc: test Disable Enable abnormal case
154 * @tc.type: FUNC
155 * @tc.require:SQL
156 */
157 HWTEST_F(DataShareSubscriberManagersTest, Disable, TestSize.Level1)
158 {
159     auto context = std::make_shared<Context>(DATA_SHARE_URI_TEST);
160     TemplateId tpltId;
161     tpltId.subscriberId_ = TEST_SUB_ID;
162     tpltId.bundleName_ = BUNDLE_NAME_TEST;
163     DataShare::Key key(context->uri, tpltId.subscriberId_, tpltId.bundleName_);
164     uint32_t tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, BUNDLE_NAME_TEST, USER_TEST);
165     auto result = RdbSubscriberManager::GetInstance().Disable(key, tokenId);
166     EXPECT_EQ(result, E_SUBSCRIBER_NOT_EXIST);
167 
168     result = RdbSubscriberManager::GetInstance().Enable(key, context);
169     EXPECT_EQ(result, E_SUBSCRIBER_NOT_EXIST);
170 }
171 
172 /**
173 * @tc.name: Emit
174 * @tc.desc: test Emit EmitByKey GetEnableObserverCount abnormal case
175 * @tc.type: FUNC
176 * @tc.require:SQL
177 */
178 HWTEST_F(DataShareSubscriberManagersTest, Emit, TestSize.Level1)
179 {
180     auto context = std::make_shared<Context>(DATA_SHARE_URI_TEST);
181     RdbSubscriberManager::GetInstance().Emit(DATA_SHARE_URI_TEST, context);
182     RdbSubscriberManager::GetInstance().Emit(DATA_SHARE_URI_TEST, TEST_SUB_ID, BUNDLE_NAME_TEST, context);
183     TemplateId tpltId;
184     tpltId.subscriberId_ = TEST_SUB_ID;
185     tpltId.bundleName_ = BUNDLE_NAME_TEST;
186     DataShare::Key key(context->uri, tpltId.subscriberId_, tpltId.bundleName_);
187     RdbSubscriberManager::GetInstance().EmitByKey(key, USER_TEST, "rdbPath", 1);
188     DataShare::Key keys("", 0, "");
189     auto result = RdbSubscriberManager::GetInstance().GetEnableObserverCount(keys);
190     EXPECT_EQ(result, 0);
191 }
192 
193 /**
194 * @tc.name: IsNotifyOnEnabled
195 * @tc.desc: test IsNotifyOnEnabled PutInto SetObserversNotifiedOnEnabled abnormal case
196 * @tc.type: FUNC
197 * @tc.require:SQL
198 */
199 HWTEST_F(DataShareSubscriberManagersTest, IsNotifyOnEnabled, TestSize.Level1)
200 {
201     auto context = std::make_shared<Context>(DATA_SHARE_URI_TEST);
202     TemplateId tpltId;
203     tpltId.subscriberId_ = TEST_SUB_ID;
204     tpltId.bundleName_ = BUNDLE_NAME_TEST;
205     DataShare::PublishedDataKey key(context->uri, tpltId.bundleName_, tpltId.subscriberId_);
206     sptr<IDataProxyPublishedDataObserver> observer;
207     std::vector<PublishedDataSubscriberManager::ObserverNode> val;
208     std::map<sptr<IDataProxyPublishedDataObserver>, std::vector<PublishedDataKey>> callbacks;
209     PublishedDataSubscriberManager::GetInstance().PutInto(callbacks, val, key, observer);
210     std::vector<PublishedDataKey> publishedKeys;
211     PublishedDataSubscriberManager::GetInstance().SetObserversNotifiedOnEnabled(publishedKeys);
212     uint32_t tokenId = AccessTokenKit::GetHapTokenID(USER_TEST, BUNDLE_NAME_TEST, USER_TEST);
213     DataShare::PublishedDataKey keys("", "", 0);
214     auto result = PublishedDataSubscriberManager::GetInstance().IsNotifyOnEnabled(keys, tokenId);
215     EXPECT_EQ(result, false);
216 }
217 
218 /**
219 * @tc.name: PublishedDataKey
220 * @tc.desc: test PublishedDataKey operator< bundleName function
221 * @tc.type: FUNC
222 * @tc.require:SQL
223 */
224 HWTEST_F(DataShareSubscriberManagersTest, PublishedDataKey, TestSize.Level1)
225 {
226     DataShare::PublishedDataKey key1(DATA_SHARE_URI_TEST, "ohos.subscribermanagertest.demo", TEST_SUB_ID);
227     DataShare::PublishedDataKey key2(DATA_SHARE_URI_TEST, "ohos.error.demo", TEST_SUB_ID);
228 
229     EXPECT_FALSE(key1 < key2);
230     EXPECT_TRUE(key2 < key1);
231 }
232 } // namespace OHOS::Test