1 /*
2 * Copyright (C) 2025 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 "datashare_connection.h"
17
18 #include <gtest/gtest.h>
19
20 #include "accesstoken_kit.h"
21 #include "data_ability_observer_interface.h"
22 #include "datashare_errno.h"
23 #include "datashare_helper.h"
24 #include "datashare_log.h"
25 #include "datashare_proxy.h"
26 #include "extension_manager_proxy.h"
27 #include "general_controller.h"
28 #include "general_controller_provider_impl.h"
29 #include "general_controller_service_impl.h"
30
31 namespace OHOS {
32 namespace DataShare {
33 using namespace testing::ext;
34 using namespace OHOS::AAFwk;
35 class DataShareConnectionTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
UrisEqual(std::list<Uri> uri1,std::list<Uri> uri2)41 bool UrisEqual(std::list<Uri> uri1, std::list<Uri> uri2)
42 {
43 if (uri1.size() != uri2.size()) {
44 return false;
45 }
46 auto cmp = [](const Uri &first, const Uri &second) {
47 return first.ToString() < second.ToString();
48 };
49 uri1.sort(cmp);
50 uri2.sort(cmp);
51 auto it1 = uri1.begin();
52 auto it2 = uri2.begin();
53 for (; it1 != uri1.end() && it2 != uri2.end(); it1++, it2++) {
54 if (!it1->Equals(*it2)) {
55 return false;
56 }
57 }
58 return true;
59 }
60 };
61
62 class RemoteObjectTest : public IRemoteObject {
63 public:
RemoteObjectTest(std::u16string descriptor)64 explicit RemoteObjectTest(std::u16string descriptor) : IRemoteObject(descriptor) {}
~RemoteObjectTest()65 ~RemoteObjectTest() {}
66
GetObjectRefCount()67 int32_t GetObjectRefCount()
68 {
69 return 0;
70 }
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)71 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
72 {
73 return 0;
74 }
AddDeathRecipient(const sptr<DeathRecipient> & recipient)75 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient)
76 {
77 return true;
78 }
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)79 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient)
80 {
81 return true;
82 }
Dump(int fd,const std::vector<std::u16string> & args)83 int Dump(int fd, const std::vector<std::u16string> &args)
84 {
85 return 0;
86 }
87 };
88
89 class IDataAbilityObserverTest : public DataAbilityObserverStub {
90 public:
IDataAbilityObserverTest(std::string uri)91 explicit IDataAbilityObserverTest(std::string uri) {uri_ = uri;}
~IDataAbilityObserverTest()92 ~IDataAbilityObserverTest()
93 {}
94
OnChange()95 void OnChange()
96 {
97 GTEST_LOG_(INFO) << "OnChange enter";
98 }
99 std::string uri_;
100 };
101
102 std::string DATA_SHARE_URI = "datashare:///com.acts.datasharetest";
103 std::string DATA_SHARE_URI1 = "datashare:///com.acts.datasharetest1";
104
SetUpTestCase(void)105 void DataShareConnectionTest::SetUpTestCase(void) {}
TearDownTestCase(void)106 void DataShareConnectionTest::TearDownTestCase(void) {}
SetUp(void)107 void DataShareConnectionTest::SetUp(void) {}
TearDown(void)108 void DataShareConnectionTest::TearDown(void) {}
109
110 /**
111 * @tc.name: DataShareConnection_UpdateObserverExtsProviderMap_Test_001
112 * @tc.desc: Verify normal functionality of UpdateObserverExtsProviderMap method
113 * @tc.type: FUNC
114 * @tc.precon: None
115 * @tc.step:
116 1. Create DataShareConnection with test URI and token
117 2. Verify observer map is initially empty
118 3. Add two observers with different URIs using UpdateObserverExtsProviderMap
119 4. Check that observer map size is correctly updated
120 * @tc.expect:
121 1. Observer map is empty initially
122 2. After adding observers, map size becomes 2
123 */
124 HWTEST_F(DataShareConnectionTest, DataShareConnection_UpdateObserverExtsProviderMap_Test_001, TestSize.Level0)
125 {
126 LOG_INFO("DataShareConnection_UpdateObserverExtsProviderMap_Test_001::Start");
127
128 Uri uri(DATA_SHARE_URI);
129 std::u16string tokenString = u"OHOS.DataShare.IDataShare";
130 sptr<IRemoteObject> token = new (std::nothrow) RemoteObjectTest(tokenString);
131 ASSERT_NE(token, nullptr);
132 sptr<DataShare::DataShareConnection> connection =
133 new (std::nothrow) DataShare::DataShareConnection(uri, token);
134 ASSERT_NE(connection, nullptr);
135
136 // insert data
137 EXPECT_TRUE(connection->observerExtsProvider_.Empty());
138 sptr<IDataAbilityObserverTest> dataObserver = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI);
139 ASSERT_NE(dataObserver, nullptr);
140 connection->UpdateObserverExtsProviderMap(uri, dataObserver, true);
141
142 Uri uri1(DATA_SHARE_URI1);
143 sptr<IDataAbilityObserverTest> dataObserver1 = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI1);
144 ASSERT_NE(dataObserver1, nullptr);
145 connection->UpdateObserverExtsProviderMap(uri1, dataObserver1, true);
146
147 EXPECT_FALSE(connection->observerExtsProvider_.Empty());
148 EXPECT_EQ(connection->observerExtsProvider_.Size(), 2);
149 connection = nullptr;
150
151 LOG_INFO("DataShareConnection_UpdateObserverExtsProviderMap_Test_001::End");
152 }
153
154 /**
155 * @tc.name: DataShareConnection_DeleteObserverExtsProviderMap_001
156 * @tc.desc: Verify DeleteObserverExtsProviderMap functionality for removing observers
157 * @tc.type: FUNC
158 * @tc.precon: None
159 * @tc.step:
160 1. Create DataShareConnection and add two observers
161 2. Verify initial map size is 2
162 3. Delete one valid observer and check map size
163 4. Attempt to delete an invalid observer and check map size remains unchanged
164 * @tc.expect:
165 1. After first deletion, map size is 1
166 2. After second deletion attempt, map size remains 1
167 */
168 HWTEST_F(DataShareConnectionTest, DataShareConnection_DeleteObserverExtsProviderMap_001, TestSize.Level0)
169 {
170 LOG_INFO("DataShareConnection_DeleteObserverExtsProviderMap_001::Start");
171
172 Uri uri(DATA_SHARE_URI);
173 std::u16string tokenString = u"OHOS.DataShare.IDataShare";
174 sptr<IRemoteObject> token = new (std::nothrow) RemoteObjectTest(tokenString);
175 ASSERT_NE(token, nullptr);
176 sptr<DataShare::DataShareConnection> connection =
177 new (std::nothrow) DataShare::DataShareConnection(uri, token);
178 ASSERT_NE(connection, nullptr);
179
180 // insert data
181 EXPECT_TRUE(connection->observerExtsProvider_.Empty());
182 sptr<IDataAbilityObserverTest> dataObserver = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI);
183 connection->UpdateObserverExtsProviderMap(uri, dataObserver, true);
184
185 Uri uri1(DATA_SHARE_URI1);
186 sptr<IDataAbilityObserverTest> dataObserver1 = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI1);
187 connection->UpdateObserverExtsProviderMap(uri1, dataObserver1, true);
188
189 EXPECT_FALSE(connection->observerExtsProvider_.Empty());
190 EXPECT_EQ(connection->observerExtsProvider_.Size(), 2);
191
192 // delete data that uri can match observer
193 connection->DeleteObserverExtsProviderMap(uri1, dataObserver1);
194 EXPECT_EQ(connection->observerExtsProvider_.Size(), 1);
195
196 // delete data that uri can not match observer
197 connection->DeleteObserverExtsProviderMap(uri1, dataObserver);
198 EXPECT_EQ(connection->observerExtsProvider_.Size(), 1);
199 connection = nullptr;
200
201 LOG_INFO("DataShareConnection_DeleteObserverExtsProviderMap_001::End");
202 }
203
204 /**
205 * @tc.name: DataShareConnection_ReRegisterObserverExtProvider_Test_001
206 * @tc.desc: Verify ReRegisterObserverExtProvider can re-register existing observers
207 * @tc.type: FUNC
208 * @tc.precon: None
209 * @tc.step:
210 1. Create DataShareConnection with valid proxy
211 2. Add two observers to the map
212 3. Call ReRegisterObserverExtProvider method
213 4. Verify observer map remains populated after re-registration
214 * @tc.expect:
215 1. Observer map remains non-empty after re-registration
216 */
217 HWTEST_F(DataShareConnectionTest, DataShareConnection_ReRegisterObserverExtProvider_Test_001, TestSize.Level0)
218 {
219 LOG_INFO("DataShareConnection_ReRegisterObserverExtProvider_Test_001::Start");
220
221 Uri uri(DATA_SHARE_URI);
222 std::u16string tokenString = u"OHOS.DataShare.IDataShare";
223 sptr<IRemoteObject> token = new (std::nothrow) RemoteObjectTest(tokenString);
224 ASSERT_NE(token, nullptr);
225 sptr<DataShare::DataShareConnection> connection =
226 new (std::nothrow) DataShare::DataShareConnection(uri, token);
227 ASSERT_NE(connection, nullptr);
228
229 // get proxy not null
230 std::shared_ptr<DataShareProxy> tokenProxy = std::make_shared<DataShareProxy>(token);
231 ASSERT_NE(tokenProxy, nullptr);
232 connection->dataShareProxy_ = tokenProxy;
233
234 // insert data
235 EXPECT_TRUE(connection->observerExtsProvider_.Empty());
236 sptr<IDataAbilityObserverTest> dataObserver = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI);
237 connection->UpdateObserverExtsProviderMap(uri, dataObserver, true);
238
239 Uri uri1(DATA_SHARE_URI1);
240 sptr<IDataAbilityObserverTest> dataObserver1 = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI1);
241 connection->UpdateObserverExtsProviderMap(uri1, dataObserver1, true);
242
243 EXPECT_FALSE(connection->observerExtsProvider_.Empty());
244 EXPECT_EQ(connection->observerExtsProvider_.Size(), 2);
245
246 // test ReRegister func
247 connection->ReRegisterObserverExtProvider();
248 // reRegister success, update observer map
249 EXPECT_FALSE(connection->observerExtsProvider_.Empty());
250 connection = nullptr;
251
252 LOG_INFO("DataShareConnection_ReRegisterObserverExtProvider_Test_001::End");
253 }
254
255 /**
256 * @tc.name: DataShareConnection_OnAbilityConnectDone_Test_001
257 * @tc.desc: Verify OnAbilityConnectDone handles reconnection and observer reregistration
258 * @tc.type: FUNC
259 * @tc.precon: None
260 * @tc.step:
261 1. Create DataShareConnection with valid proxy and observers
262 2. Set isReconnect_ flag to true
263 3. Call OnAbilityConnectDone with test parameters
264 4. Verify observer map remains intact after connection
265 * @tc.expect:
266 1. Observer map remains non-empty after connection completes
267 */
268 HWTEST_F(DataShareConnectionTest, DataShareConnection_OnAbilityConnectDone_Test_001, TestSize.Level0)
269 {
270 LOG_INFO("DataShareConnection_OnAbilityConnectDone_Test_001::Start");
271
272 Uri uri(DATA_SHARE_URI);
273 std::u16string tokenString = u"OHOS.DataShare.IDataShare";
274 sptr<IRemoteObject> token = new (std::nothrow) RemoteObjectTest(tokenString);
275 ASSERT_NE(token, nullptr);
276 sptr<DataShare::DataShareConnection> connection =
277 new (std::nothrow) DataShare::DataShareConnection(uri, token);
278 ASSERT_NE(connection, nullptr);
279
280 // get proxy not null
281 std::shared_ptr<DataShareProxy> tokenProxy = std::make_shared<DataShareProxy>(token);
282 ASSERT_NE(tokenProxy, nullptr);
283 connection->dataShareProxy_ = tokenProxy;
284
285 // insert data
286 EXPECT_TRUE(connection->observerExtsProvider_.Empty());
287 sptr<IDataAbilityObserverTest> dataObserver = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI);
288 connection->UpdateObserverExtsProviderMap(uri, dataObserver, true);
289
290 Uri uri1(DATA_SHARE_URI1);
291 sptr<IDataAbilityObserverTest> dataObserver1 = new (std::nothrow) IDataAbilityObserverTest(DATA_SHARE_URI1);
292 connection->UpdateObserverExtsProviderMap(uri1, dataObserver1, true);
293
294 EXPECT_FALSE(connection->observerExtsProvider_.Empty());
295 EXPECT_EQ(connection->observerExtsProvider_.Size(), 2);
296
297 // test ReRegister func
298 connection->isReconnect_.store(true);
299 std::string deviceId = "deviceId";
300 std::string bundleName = "bundleName";
301 std::string abilityName = "abilityName";
302 AppExecFwk::ElementName element(deviceId, bundleName, abilityName);
303 int resultCode = 0;
304 connection->OnAbilityConnectDone(element, token, resultCode);
305
306 // reRegister success, update observer map
307 EXPECT_FALSE(connection->observerExtsProvider_.Empty());
308 connection = nullptr;
309
310 LOG_INFO("DataShareConnection_OnAbilityConnectDone_Test_001::End");
311 }
312
313 /**
314 * @tc.name: DataShareConnection_OnAbilityDisconnectDone_Test_001
315 * @tc.desc: Verify thread name is correctly set after disconnection
316 * @tc.type: FUNC
317 * @tc.precon: None
318 * @tc.step:
319 1. Create DataShareConnection and set isReconnect_ to true
320 2. Call OnAbilityDisconnectDone with test parameters
321 3. Check that the thread name in the connection pool is correct
322 * @tc.expect:
323 1. Thread name is set to "DShare_Connect"
324 */
325 HWTEST_F(DataShareConnectionTest, DataShareConnection_OnAbilityDisconnectDone_Test_001, TestSize.Level1)
326 {
327 LOG_INFO("DataShareConnection_OnAbilityDisconnectDone_Test_001::Start");
328 Uri uri(DATA_SHARE_URI);
329 std::u16string tokenString = u"OHOS.DataShare.IDataShare";
330 sptr<IRemoteObject> token = new (std::nothrow) RemoteObjectTest(tokenString);
331 sptr<DataShare::DataShareConnection> connection =
332 new (std::nothrow) DataShare::DataShareConnection(uri, token);
333
334 connection->isReconnect_.store(true);
335 std::string deviceId = "deviceId";
336 std::string bundleName = "bundleName";
337 std::string abilityName = "abilityName";
338 AppExecFwk::ElementName element(deviceId, bundleName, abilityName);
339 int resultCode = 0;
340 connection->OnAbilityDisconnectDone(element, resultCode);
341 EXPECT_EQ(connection->pool_->pool_.threadName_, DATASHARE_EXECUTOR_NAME);
342 LOG_INFO("DataShareConnection_OnAbilityDisconnectDone_Test_001::End");
343 }
344 }
345 }