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 #include "datashare_helper_impl.h"
16 #include "general_controller_service_impl.h"
17
18 #include <gtest/gtest.h>
19
20 #include <memory>
21
22 #include "datashare_log.h"
23 #include "gmock/gmock.h"
24
25 namespace OHOS {
26 namespace DataShare {
27 using namespace testing::ext;
28
29 class MockGeneralController : public GeneralController {
30 public:
31 MOCK_METHOD(int, Insert, (const Uri &uri, const DataShareValuesBucket &value), (override));
32 MOCK_METHOD(int, Update,
33 (const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value), (override));
34 MOCK_METHOD(int, Delete, (const Uri &uri, const DataSharePredicates &predicates), (override));
35 MOCK_METHOD((std::shared_ptr<DataShareResultSet>), Query,
36 (const Uri &uri, const DataSharePredicates &predicates, (std::vector<std::string> & columns),
37 DatashareBusinessError &businessError, DataShareOption &option), (override));
38 MOCK_METHOD(
39 int, RegisterObserver, (const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver), (override));
40 MOCK_METHOD(int32_t, UnregisterObserver, (const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver),
41 (override));
42 MOCK_METHOD(void, NotifyChange, (const Uri &uri), (override));
43 MOCK_METHOD(
44 int, RegisterObserverExtProvider, (const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver,
45 bool isDescendants), (override));
46 MOCK_METHOD(int32_t, UnregisterObserverExtProvider, (const Uri &uri,
47 const sptr<AAFwk::IDataAbilityObserver> &dataObserver), (override));
48 MOCK_METHOD(int32_t, NotifyChangeExtProvider, (const ChangeInfo &changeInfo), (override));
49 MOCK_METHOD(
50 (std::pair<int32_t, int32_t>), InsertEx, (const Uri &uri, const DataShareValuesBucket &value), (override));
51 MOCK_METHOD((std::pair<int32_t, int32_t>), UpdateEx,
52 (const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value), (override));
53 MOCK_METHOD(
54 (std::pair<int32_t, int32_t>), DeleteEx, (const Uri &uri, const DataSharePredicates &predicates), (override));
55 };
56
57 class DataShareHelperImplTest : public testing::Test {
58 public:
59 static void SetUpTestCase(void);
60 static void TearDownTestCase(void);
61 void SetUp();
62 void TearDown();
63 static std::shared_ptr<DataShareHelperImpl> GetInstance(std::shared_ptr<DataShareHelperImpl> instance = nullptr);
64 static std::shared_ptr<MockGeneralController> GetController(
65 std::shared_ptr<MockGeneralController> instance = nullptr);
66 };
67
SetUpTestCase(void)68 void DataShareHelperImplTest::SetUpTestCase(void)
69 {
70 DataShareHelperImplTest::GetInstance(std::make_shared<DataShareHelperImpl>("datashare://datasharehelperimpl"));
71 EXPECT_NE(DataShareHelperImplTest::GetInstance(), nullptr);
72 DataShareHelperImplTest::GetController(std::make_shared<MockGeneralController>());
73 EXPECT_NE(DataShareHelperImplTest::GetController(), nullptr);
74 DataShareHelperImplTest::GetInstance()->generalCtl_ = DataShareHelperImplTest::GetController();
75 EXPECT_NE(DataShareHelperImplTest::GetInstance()->generalCtl_, nullptr);
76 EXPECT_EQ(DataShareHelperImplTest::GetInstance()->extSpCtl_, nullptr);
77 DataShareHelperImplTest::GetInstance()->persistentDataCtl_ = nullptr;
78 DataShareHelperImplTest::GetInstance()->publishedDataCtl_ = nullptr;
79 }
TearDownTestCase(void)80 void DataShareHelperImplTest::TearDownTestCase(void)
81 {
82 }
SetUp(void)83 void DataShareHelperImplTest::SetUp(void)
84 {
85 }
TearDown(void)86 void DataShareHelperImplTest::TearDown(void)
87 {
88 }
GetInstance(std::shared_ptr<DataShareHelperImpl> instance)89 std::shared_ptr<DataShareHelperImpl> DataShareHelperImplTest::GetInstance(std::shared_ptr<DataShareHelperImpl> instance)
90 {
91 static std::shared_ptr<DataShareHelperImpl> helperInstance = nullptr;
92 if (instance != nullptr) {
93 helperInstance = instance;
94 }
95 return helperInstance;
96 }
GetController(std::shared_ptr<MockGeneralController> instance)97 std::shared_ptr<MockGeneralController> DataShareHelperImplTest::GetController(
98 std::shared_ptr<MockGeneralController> instance)
99 {
100 static std::shared_ptr<MockGeneralController> controllerInstance = nullptr;
101 if (instance != nullptr) {
102 controllerInstance = instance;
103 }
104 return controllerInstance;
105 }
106
107 /**
108 * @tc.name: QueryTest001
109 * @tc.desc: Verify Query function behavior under different controller states
110 * @tc.type: FUNC
111 * @tc.require: issueIC8OCN
112 * @tc.precon: DataShareHelperImpl instance is properly initialized
113 * @tc.step:
114 1. Create test URI and empty predicates/columns
115 2. Set general controller to null and execute Query
116 3. Initialize mock controller and set it as general controller
117 4. Verify Query returns expected result set with mock controller
118 5. Verify Query works with business error parameter
119 * @tc.expect:
120 1. Query returns nullptr when controller is null
121 2. Query returns expected result set when using mock controller
122 3. Query works correctly with business error parameter
123 */
124 HWTEST_F(DataShareHelperImplTest, QueryTest001, TestSize.Level0)
125 {
126 LOG_INFO("QueryTest001::Start");
127 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
128 DataSharePredicates predicates;
129 std::vector<std::string> columns;
130 DataShareHelperImplTest::GetInstance()->generalCtl_ = nullptr;
131 auto result = DataShareHelperImplTest::GetInstance()->Query(uri, predicates, columns, nullptr);
132 EXPECT_EQ(result, nullptr);
133 auto expectResult = std::make_shared<DataShareResultSet>();
134 std::shared_ptr<MockGeneralController> controller = DataShareHelperImplTest::GetController();
135 DataShareHelperImplTest::GetInstance()->generalCtl_ = controller;
136 EXPECT_CALL(*controller, Query(testing::_, testing::_, testing::_, testing::_, testing::_))
137 .WillOnce(testing::Return(expectResult));
138 result = DataShareHelperImplTest::GetInstance()->Query(uri, predicates, columns, nullptr);
139 EXPECT_EQ(result, expectResult);
140 DatashareBusinessError error;
141 EXPECT_CALL(*controller, Query(testing::_, testing::_, testing::_, testing::_, testing::_))
142 .WillOnce(testing::Return(expectResult));
143 result = DataShareHelperImplTest::GetInstance()->Query(uri, predicates, columns, &error);
144 EXPECT_EQ(result, expectResult);
145 LOG_INFO("QueryTest001::End");
146 }
147
148 /**
149 * @tc.name: QueryTimeoutTest001
150 * @tc.desc: Verify QueryTimeout function behavior under different controller states
151 * @tc.type: FUNC
152 * @tc.require: issueIC8OCN
153 * @tc.precon: DataShareHelperImpl instance is properly initialized
154 * @tc.step:
155 1. Create test URI, empty predicates/columns and default option
156 2. Set general controller to null and execute QueryTimeout
157 3. Initialize mock controller and set it as general controller
158 4. Verify QueryTimeout returns expected result set with mock controller
159 5. Verify QueryTimeout works with business error parameter
160 * @tc.expect:
161 1. QueryTimeout returns nullptr when controller is null
162 2. QueryTimeout returns expected result set when using mock controller
163 3. QueryTimeout works correctly with business error parameter
164 */
165 HWTEST_F(DataShareHelperImplTest, QueryTimeoutTest001, TestSize.Level0)
166 {
167 LOG_INFO("QueryTimeoutTest001::Start");
168 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
169 DataSharePredicates predicates;
170 std::vector<std::string> columns;
171 DataShareOption option;
172 DataShareHelperImplTest::GetInstance()->generalCtl_ = nullptr;
173 auto result = DataShareHelperImplTest::GetInstance()->Query(uri, predicates, columns, option, nullptr);
174 EXPECT_EQ(result, nullptr);
175 auto expectResult = std::make_shared<DataShareResultSet>();
176 std::shared_ptr<MockGeneralController> controller = DataShareHelperImplTest::GetController();
177 DataShareHelperImplTest::GetInstance()->generalCtl_ = controller;
178 EXPECT_CALL(*controller, Query(testing::_, testing::_, testing::_, testing::_, testing::_))
179 .WillOnce(testing::Return(expectResult));
180 result = DataShareHelperImplTest::GetInstance()->Query(uri, predicates, columns, option, nullptr);
181 EXPECT_EQ(result, expectResult);
182 DatashareBusinessError error;
183 EXPECT_CALL(*controller, Query(testing::_, testing::_, testing::_, testing::_, testing::_))
184 .WillOnce(testing::Return(expectResult));
185 result = DataShareHelperImplTest::GetInstance()->Query(uri, predicates, columns, option, &error);
186 EXPECT_EQ(result, expectResult);
187 LOG_INFO("QueryTimeoutTest001::End");
188 }
189
190 /**
191 * @tc.name: BatchUpdateTest001
192 * @tc.desc: Verify BatchUpdate function behavior with empty operations
193 * @tc.type: FUNC
194 * @tc.require: issueIC8OCN
195 * @tc.precon: DataShareHelperImpl instance is properly initialized
196 * @tc.step:
197 1. Create empty update operations and results vector
198 2. Execute BatchUpdate with empty parameters
199 3. Check return error code
200 * @tc.expect:
201 1. BatchUpdate returns DATA_SHARE_ERROR when given empty operations
202 */
203 HWTEST_F(DataShareHelperImplTest, BatchUpdateTest001, TestSize.Level0)
204 {
205 LOG_INFO("BatchUpdateTest001::Start");
206 UpdateOperations operations;
207 std::vector<BatchUpdateResult> results = {};
208 int result = DataShareHelperImplTest::GetInstance()->BatchUpdate(operations, results);
209 EXPECT_EQ(result, DATA_SHARE_ERROR);
210 LOG_INFO("BatchUpdateTest001::End");
211 }
212
213 /**
214 * @tc.name: InsertExTest001
215 * @tc.desc: Verify InsertEx handles null controller and error responses
216 * @tc.type: FUNC
217 * @tc.precon: None
218 * @tc.step:
219 1. Set general controller to null and call InsertEx
220 2. Restore mock controller and set expectation for error response
221 3. Call InsertEx again with valid parameters
222 4. Check returned results in both cases
223 * @tc.expect:
224 1. First call returns DATA_SHARE_ERROR
225 2. Second call returns E_REGISTERED_REPEATED error
226 */
227 HWTEST_F(DataShareHelperImplTest, InsertExTest001, TestSize.Level0)
228 {
229 LOG_INFO("InsertExTest001::Start");
230 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
231 DataShareValuesBucket value;
232 DataShareHelperImplTest::GetInstance()->generalCtl_ = nullptr;
233 std::pair<int32_t, int32_t> result = DataShareHelperImplTest::GetInstance()->InsertEx(uri, value);
234 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
235 EXPECT_EQ(result.second, 0);
236 std::shared_ptr<MockGeneralController> controller = DataShareHelperImplTest::GetController();
237 DataShareHelperImplTest::GetInstance()->generalCtl_ = controller;
238 EXPECT_CALL(*controller, InsertEx(testing::_, testing::_))
239 .WillOnce(testing::Return(std::make_pair(E_REGISTERED_REPEATED, 0)));
240 result = DataShareHelperImplTest::GetInstance()->InsertEx(uri, value);
241 EXPECT_EQ(result.first, E_REGISTERED_REPEATED);
242 EXPECT_EQ(result.second, 0);
243 LOG_INFO("InsertExTest001::End");
244 }
245
246 /**
247 * @tc.name: UpdateExTest001
248 * @tc.desc: Verify UpdateEx handles null controller and error responses
249 * @tc.type: FUNC
250 * @tc.precon: None
251 * @tc.step:
252 1. Set general controller to null and call UpdateEx
253 2. Restore mock controller and set expectation for error response
254 3. Call UpdateEx again with valid parameters
255 4. Check returned results in both cases
256 * @tc.expect:
257 1. First call returns DATA_SHARE_ERROR
258 2. Second call returns E_REGISTERED_REPEATED error
259 */
260 HWTEST_F(DataShareHelperImplTest, UpdateExTest001, TestSize.Level0)
261 {
262 LOG_INFO("UpdateExTest001::Start");
263 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
264 DataShareValuesBucket value;
265 DataSharePredicates predicates;
266 DataShareHelperImplTest::GetInstance()->generalCtl_ = nullptr;
267 std::pair<int32_t, int32_t> result = DataShareHelperImplTest::GetInstance()->UpdateEx(uri, predicates, value);
268 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
269 EXPECT_EQ(result.second, 0);
270 std::shared_ptr<MockGeneralController> controller = DataShareHelperImplTest::GetController();
271 DataShareHelperImplTest::GetInstance()->generalCtl_ = controller;
272 EXPECT_CALL(*controller, UpdateEx(testing::_, testing::_, testing::_))
273 .WillOnce(testing::Return(std::make_pair(E_REGISTERED_REPEATED, 0)));
274 result = DataShareHelperImplTest::GetInstance()->UpdateEx(uri, predicates, value);
275 EXPECT_EQ(result.first, E_REGISTERED_REPEATED);
276 EXPECT_EQ(result.second, 0);
277 LOG_INFO("UpdateExTest001::End");
278 }
279
280 /**
281 * @tc.name: DeleteExTest001
282 * @tc.desc: Verify DeleteEx handles null controller and error responses
283 * @tc.type: FUNC
284 * @tc.precon: None
285 * @tc.step:
286 1. Set general controller to null and call DeleteEx
287 2. Restore mock controller and set expectation for error response
288 3. Call DeleteEx again with valid parameters
289 4. Check returned results in both cases
290 * @tc.expect:
291 1. First call returns DATA_SHARE_ERROR
292 2. Second call returns E_REGISTERED_REPEATED error
293 */
294 HWTEST_F(DataShareHelperImplTest, DeleteExTest001, TestSize.Level0)
295 {
296 LOG_INFO("DeleteExTest001::Start");
297 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
298 DataSharePredicates predicates;
299 DataShareHelperImplTest::GetInstance()->generalCtl_ = nullptr;
300 std::pair<int32_t, int32_t> result = DataShareHelperImplTest::GetInstance()->DeleteEx(uri, predicates);
301 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
302 EXPECT_EQ(result.second, 0);
303 std::shared_ptr<MockGeneralController> controller = DataShareHelperImplTest::GetController();
304 DataShareHelperImplTest::GetInstance()->generalCtl_ = controller;
305 EXPECT_CALL(*controller, DeleteEx(testing::_, testing::_))
306 .WillOnce(testing::Return(std::make_pair(E_REGISTERED_REPEATED, 0)));
307 result = DataShareHelperImplTest::GetInstance()->DeleteEx(uri, predicates);
308 EXPECT_EQ(result.first, E_REGISTERED_REPEATED);
309 EXPECT_EQ(result.second, 0);
310 LOG_INFO("DeleteExTest001::End");
311 }
312
313 /**
314 * @tc.name: DelQueryTemplateTest001
315 * @tc.desc: Verify DelQueryTemplate returns error with valid parameters
316 * @tc.type: FUNC
317 * @tc.precon: None
318 * @tc.step:
319 1. Call DelQueryTemplate with test URI and subscriber ID
320 2. Check returned result code
321 * @tc.expect:
322 1. DelQueryTemplate returns DATA_SHARE_ERROR
323 */
324 HWTEST_F(DataShareHelperImplTest, DelQueryTemplateTest001, TestSize.Level0)
325 {
326 LOG_INFO("DelQueryTemplateTest001::Start");
327 std::string uri("datashare:///com.datasharehelperimpl.test");
328 int64_t subscriberId = 0;
329 int result = DataShareHelperImplTest::GetInstance()->DelQueryTemplate(uri, subscriberId);
330 EXPECT_EQ(result, DATA_SHARE_ERROR);
331 LOG_INFO("DelQueryTemplateTest001::End");
332 }
333
334 /**
335 * @tc.name: PublishTest001
336 * @tc.desc: Verify Publish returns empty result with valid parameters
337 * @tc.type: FUNC
338 * @tc.precon: None
339 * @tc.step:
340 1. Create empty Data object and test bundle name
341 2. Call Publish with these parameters
342 3. Check size of returned result vector
343 * @tc.expect:
344 1. Returned result vector is empty
345 */
346 HWTEST_F(DataShareHelperImplTest, PublishTest001, TestSize.Level0)
347 {
348 LOG_INFO("PublishTest001::Start");
349 Data data;
350 std::string bundleName("datashare:///com.datasharehelperimpl.test");
351 std::vector<OperationResult> result = DataShareHelperImplTest::GetInstance()->Publish(data, bundleName);
352 EXPECT_EQ(result.size(), 0);
353 LOG_INFO("PublishTest001::End");
354 }
355
356 /**
357 * @tc.name: GetPublishedDataTest001
358 * @tc.desc: Verify GetPublishedData returns empty data with valid parameters
359 * @tc.type: FUNC
360 * @tc.precon: None
361 * @tc.step:
362 1. Create test bundle name and result code variable
363 2. Call GetPublishedData with these parameters
364 3. Check version and size of returned Data object
365 * @tc.expect:
366 1. Returned Data object has version 0 and empty data vector
367 */
368 HWTEST_F(DataShareHelperImplTest, GetPublishedDataTest001, TestSize.Level0)
369 {
370 LOG_INFO("GetPublishedDataTest001::Start");
371 int resultCode = 0;
372 std::string bundleName("datashare:///com.datasharehelperimpl.test");
373 Data result = DataShareHelperImplTest::GetInstance()->GetPublishedData(bundleName, resultCode);
374 EXPECT_EQ(result.version_, 0);
375 EXPECT_EQ(result.datas_.size(), 0);
376 LOG_INFO("GetPublishedDataTest001::End");
377 }
378
379 /**
380 * @tc.name: SubscribeRdbDataTest001
381 * @tc.desc: Verify SubscribeRdbData returns empty result with empty URIs
382 * @tc.type: FUNC
383 * @tc.precon: None
384 * @tc.step:
385 1. Create empty URIs vector, template ID and callback
386 2. Call SubscribeRdbData with these parameters
387 3. Check size of returned result vector
388 * @tc.expect:
389 1. Returned result vector is empty
390 */
391 HWTEST_F(DataShareHelperImplTest, SubscribeRdbDataTest001, TestSize.Level0)
392 {
393 LOG_INFO("SubscribeRdbDataTest001::Start");
394 std::vector<std::string> uris = {};
395 TemplateId templateId;
396 std::function<void(const RdbChangeNode &changeNode)> callback;
397 std::vector<OperationResult> result =
398 DataShareHelperImplTest::GetInstance()->SubscribeRdbData(uris, templateId, callback);
399 EXPECT_EQ(result.size(), 0);
400 LOG_INFO("SubscribeRdbDataTest001::End");
401 }
402
403 /**
404 * @tc.name: UnsubscribeRdbDataTest001
405 * @tc.desc: Verify UnsubscribeRdbData returns empty result with empty URIs
406 * @tc.type: FUNC
407 * @tc.precon: None
408 * @tc.step:
409 1. Create empty URIs vector and template ID
410 2. Call UnsubscribeRdbData with these parameters
411 3. Check size of returned result vector
412 * @tc.expect:
413 1. Returned result vector is empty
414 */
415 HWTEST_F(DataShareHelperImplTest, UnsubscribeRdbDataTest001, TestSize.Level0)
416 {
417 LOG_INFO("UnsubscribeRdbDataTest001::Start");
418 std::vector<std::string> uris = {};
419 TemplateId templateId;
420 std::vector<OperationResult> result = DataShareHelperImplTest::GetInstance()->UnsubscribeRdbData(uris, templateId);
421 EXPECT_EQ(result.size(), 0);
422 LOG_INFO("UnsubscribeRdbDataTest001::End");
423 }
424
425 /**
426 * @tc.name: DisableRdbSubsTest001
427 * @tc.desc: Verify DisableRdbSubs returns empty result with empty URIs
428 * @tc.type: FUNC
429 * @tc.precon: None
430 * @tc.step:
431 1. Create empty URIs vector and template ID
432 2. Call DisableRdbSubs with these parameters
433 3. Check size of returned result vector
434 * @tc.expect:
435 1. Returned result vector is empty
436 */
437 HWTEST_F(DataShareHelperImplTest, DisableRdbSubsTest001, TestSize.Level0)
438 {
439 LOG_INFO("DisableRdbSubsTest001::Start");
440 std::vector<std::string> uris = {};
441 TemplateId templateId;
442 std::vector<OperationResult> result = DataShareHelperImplTest::GetInstance()->DisableRdbSubs(uris, templateId);
443 EXPECT_EQ(result.size(), 0);
444 LOG_INFO("DisableRdbSubsTest001::End");
445 }
446
447 /**
448 * @tc.name: SubscribePublishedDataTest001
449 * @tc.desc: Verify SubscribePublishedData returns empty result with empty URIs
450 * @tc.type: FUNC
451 * @tc.precon: None
452 * @tc.step:
453 1. Create empty URIs vector, subscriber ID and callback
454 2. Call SubscribePublishedData with these parameters
455 3. Check size of returned result vector
456 * @tc.expect:
457 1. Returned result vector is empty
458 */
459 HWTEST_F(DataShareHelperImplTest, SubscribePublishedDataTest001, TestSize.Level0)
460 {
461 LOG_INFO("SubscribePublishedDataTest001::Start");
462 std::vector<std::string> uris = {};
463 int64_t subscriberId = 0;
464 std::function<void(const PublishedDataChangeNode &changeNode)> callback;
465 std::vector<OperationResult> result =
466 DataShareHelperImplTest::GetInstance()->SubscribePublishedData(uris, subscriberId, callback);
467 EXPECT_EQ(result.size(), 0);
468 LOG_INFO("SubscribePublishedDataTest001::End");
469 }
470
471 /**
472 * @tc.name: UnsubscribePublishedDataTest001
473 * @tc.desc: Verify UnsubscribePublishedData returns empty result with empty URIs
474 * @tc.type: FUNC
475 * @tc.precon: None
476 * @tc.step:
477 1. Create empty URIs vector and subscriber ID
478 2. Call UnsubscribePublishedData with these parameters
479 3. Check size of returned result vector
480 * @tc.expect:
481 1. Returned result vector is empty
482 */
483 HWTEST_F(DataShareHelperImplTest, UnsubscribePublishedDataTest001, TestSize.Level0)
484 {
485 LOG_INFO("UnsubscribePublishedDataTest001::Start");
486 std::vector<std::string> uris = {};
487 int64_t subscriberId = 0;
488 std::vector<OperationResult> result =
489 DataShareHelperImplTest::GetInstance()->UnsubscribePublishedData(uris, subscriberId);
490 EXPECT_EQ(result.size(), 0);
491 LOG_INFO("UnsubscribePublishedDataTest001::End");
492 }
493
494 /**
495 * @tc.name: EnablePubSubsTest001
496 * @tc.desc: Verify EnablePubSubs returns empty result with empty URIs
497 * @tc.type: FUNC
498 * @tc.precon: None
499 * @tc.step:
500 1. Create empty URIs vector and subscriber ID
501 2. Call EnablePubSubs with these parameters
502 3. Check size of returned result vector
503 * @tc.expect:
504 1. Returned result vector is empty
505 */
506 HWTEST_F(DataShareHelperImplTest, EnablePubSubsTest001, TestSize.Level0)
507 {
508 LOG_INFO("EnablePubSubsTest001::Start");
509 std::vector<std::string> uris = {};
510 int64_t subscriberId = 0;
511 std::vector<OperationResult> result = DataShareHelperImplTest::GetInstance()->EnablePubSubs(uris, subscriberId);
512 EXPECT_EQ(result.size(), 0);
513 LOG_INFO("EnablePubSubsTest001::End");
514 }
515
516 /**
517 * @tc.name: DisablePubSubsTest001
518 * @tc.desc: Verify DisablePubSubs returns empty result with empty URIs
519 * @tc.type: FUNC
520 * @tc.precon: None
521 * @tc.step:
522 1. Create empty URIs vector and subscriber ID
523 2. Call DisablePubSubs with these parameters
524 3. Check size of returned result vector
525 * @tc.expect:
526 1. Returned result vector is empty
527 */
528 HWTEST_F(DataShareHelperImplTest, DisablePubSubsTest001, TestSize.Level0)
529 {
530 LOG_INFO("DisablePubSubsTest001::Start");
531 std::vector<std::string> uris = {};
532 int64_t subscriberId = 0;
533 std::vector<OperationResult> result = DataShareHelperImplTest::GetInstance()->DisablePubSubs(uris, subscriberId);
534 EXPECT_EQ(result.size(), 0);
535 LOG_INFO("DisablePubSubsTest001::End");
536 }
537
538 /**
539 * @tc.name: User_Define_func_No_ExtSpCtl_Test001
540 * @tc.desc: Verify UserDefineFunc returns error when extSpCtl_ is null
541 * @tc.type: FUNC
542 * @tc.precon: None
543 * @tc.step:
544 1. Set extSpCtl_ to null
545 2. Create empty MessageParcel objects and MessageOption
546 3. Call UserDefineFunc with these parameters
547 4. Check returned result code
548 * @tc.expect:
549 1. UserDefineFunc returns DATA_SHARE_ERROR
550 */
551 HWTEST_F(DataShareHelperImplTest, User_Define_func_No_ExtSpCtl_Test001, TestSize.Level0)
552 {
553 LOG_INFO("User_Define_func_No_ExtSpCtl_Test001::Start");
554 DataShareHelperImplTest::GetInstance()->extSpCtl_ = nullptr;
555 MessageParcel data;
556 MessageParcel reply;
557 MessageOption option;
558 auto result = DataShareHelperImplTest::GetInstance()->UserDefineFunc(data, reply, option);
559 EXPECT_EQ(result, DATA_SHARE_ERROR);
560 LOG_INFO("User_Define_func_No_ExtSpCtl_Test001::End");
561 }
562
563 class MockDataShareServiceProxy : public DataShareServiceProxy {
564 public:
MockDataShareServiceProxy(const sptr<IRemoteObject> & impl)565 explicit MockDataShareServiceProxy(const sptr<IRemoteObject>& impl) : DataShareServiceProxy(impl) {}
566 ~MockDataShareServiceProxy() = default;
567
Query(const Uri & uri,const Uri & extUri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)568 std::shared_ptr<DataShareResultSet> Query(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicates,
569 std::vector<std::string> &columns, DatashareBusinessError &businessError)
570 {
571 businessError.SetCode(E_OK);
572 std::this_thread::sleep_for(std::chrono::seconds(3)); // sleep 3s
573 return nullptr;
574 }
575 };
576
577 /**
578 * @tc.name: QueryTimeoutTest002
579 * @tc.desc: Test Query function with timeout option
580 * @tc.type: FUNC
581 * @tc.require: issueIC8OCN
582 * @tc.precon: None
583 * @tc.step:
584 1. Create GeneralControllerServiceImpl and call Query with default option
585 2. Set option timeout to 1 and call Query function again
586 3. Set pool_ to nullptr and call Query function the third time
587 * @tc.experct: All Query calls return nullptr
588 */
589 HWTEST_F(DataShareHelperImplTest, QueryTimeoutTest002, TestSize.Level0)
590 {
591 LOG_INFO("QueryTimeoutTest002::Start");
592 sptr<IRemoteObject> remoteObject;
593 std::shared_ptr<MockDataShareServiceProxy> service = std::make_shared<MockDataShareServiceProxy>(remoteObject);
594 auto manager = DataShareManagerImpl::GetInstance();
595 manager->dataShareService_ = static_cast<std::shared_ptr<DataShareServiceProxy>>(service);
596 auto generalCtl = GeneralControllerServiceImpl("datashare://datasharehelperimpl");
597 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
598 DataSharePredicates predicates;
599 std::vector<std::string> columns;
600 DataShareOption option;
601 DatashareBusinessError businessError;
602 auto res = generalCtl.Query(uri, predicates, columns, businessError, option);
603 EXPECT_EQ(res, nullptr);
604
605 option.timeout = 1;
606 res = generalCtl.Query(uri, predicates, columns, businessError, option);
607 EXPECT_EQ(businessError.GetCode(), E_TIMEOUT_ERROR);
608
609 option.timeout = 4000; // time out lager than task execute time
610 res = generalCtl.Query(uri, predicates, columns, businessError, option);
611 EXPECT_EQ(businessError.GetCode(), E_OK);
612
613 generalCtl.pool_ = nullptr;
614 res = generalCtl.Query(uri, predicates, columns, businessError, option);
615 EXPECT_EQ(businessError.GetCode(), E_EXECUTOR_POOL_IS_NULL);
616 LOG_INFO("QueryTimeoutTest002::End");
617 }
618
619 /**
620 * @tc.name: QueryTimeoutTest003
621 * @tc.desc: Test Query function timeout scenarios with different timeout values
622 * @tc.type: FUNC
623 * @tc.require: issueIC8OCN
624 * @tc.precon: None
625 * @tc.step:
626 1. Set up MockDataShareServiceProxy and GeneralControllerServiceImpl
627 2. Call Query with timeout less than task execute time
628 3. Call Query with timeout larger than task execute time
629 * @tc.experct: First call returns E_TIMEOUT_ERROR, second call returns E_OK
630 */
631 HWTEST_F(DataShareHelperImplTest, QueryTimeoutTest003, TestSize.Level0)
632 {
633 LOG_INFO("QueryTimeoutTest003::Start");
634 sptr<IRemoteObject> remoteObject;
635 std::shared_ptr<MockDataShareServiceProxy> service = std::make_shared<MockDataShareServiceProxy>(remoteObject);
636 auto manager = DataShareManagerImpl::GetInstance();
637 manager->dataShareService_ = static_cast<std::shared_ptr<DataShareServiceProxy>>(service);
638
639 auto generalCtl = std::make_shared<GeneralControllerServiceImpl>("datashare://datasharehelperimpl");
640 auto helper = DataShareHelperImplTest::GetInstance();
641 helper->generalCtl_ = generalCtl;
642
643 OHOS::Uri uri("datashare:///com.datasharehelperimpl.test");
644 DataSharePredicates predicates;
645 std::vector<std::string> columns;
646 DataShareOption option;
647 option.timeout = 2000; // time out less than task execute time
648 DatashareBusinessError businessError;
649 auto res = helper->Query(uri, predicates, columns, option, &businessError);
650 EXPECT_EQ(businessError.GetCode(), E_TIMEOUT_ERROR);
651
652 option.timeout = 4000; // time out lager than task execute time
653 res = helper->Query(uri, predicates, columns, option, &businessError);
654 EXPECT_EQ(businessError.GetCode(), E_OK);
655
656 option.timeout = 0;
657 res = helper->Query(uri, predicates, columns, option, &businessError);
658 EXPECT_EQ(businessError.GetCode(), E_OK);
659 LOG_INFO("QueryTimeoutTest003::End");
660 }
661 } // namespace DataShare
662 } // namespace OHOS