1 /*
2 * Copyright (C) 2023 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 <gtest/gtest.h>
16 #include <unistd.h>
17
18 #include "accesstoken_kit.h"
19 #include "datashare_helper.h"
20 #include "datashare_log.h"
21 #include "datashare_template.h"
22 #include "hap_token_info.h"
23 #include "iservice_registry.h"
24 #include "system_ability_definition.h"
25 #include "token_setproc.h"
26 #include "datashare_errno.h"
27
28 namespace OHOS {
29 namespace DataShare {
30 using namespace testing::ext;
31 using namespace OHOS::Security::AccessToken;
32 std::string DATA_SHARE_PROXY_URI = "datashareproxy://com.acts.ohos.data.datasharetest/test";
33 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper;
34 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper2; // for another subscriber
35 std::string TBL_NAME0 = "name0";
36 std::string TBL_NAME1 = "name1";
37 constexpr int SUBSCRIBER_ID = 100;
38 std::atomic_int g_callbackTimes = 0;
39
40 class ProxyDatasTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase(void)48 void ProxyDatasTest::SetUpTestCase(void)
49 {
50 LOG_INFO("SetUpTestCase invoked");
51 int sleepTime = 1;
52 sleep(sleepTime);
53
54 HapInfoParams info = { .userID = 100,
55 .bundleName = "ohos.datashareproxyclienttest.demo",
56 .instIndex = 0,
57 .appIDDesc = "ohos.datashareproxyclienttest.demo" };
58 HapPolicyParams policy = { .apl = APL_SYSTEM_BASIC,
59 .domain = "test.domain",
60 .permList = { { .permissionName = "ohos.permission.GET_BUNDLE_INFO",
61 .bundleName = "ohos.datashareproxyclienttest.demo",
62 .grantMode = 1,
63 .availableLevel = APL_SYSTEM_BASIC,
64 .label = "label",
65 .labelId = 1,
66 .description = "ohos.datashareproxyclienttest.demo",
67 .descriptionId = 1 } },
68 .permStateList = { { .permissionName = "ohos.permission.GET_BUNDLE_INFO",
69 .isGeneral = true,
70 .resDeviceID = { "local" },
71 .grantStatus = { PermissionState::PERMISSION_GRANTED },
72 .grantFlags = { 1 } } } };
73 AccessTokenKit::AllocHapToken(info, policy);
74 auto testTokenId =
75 Security::AccessToken::AccessTokenKit::GetHapTokenID(info.userID, info.bundleName, info.instIndex);
76 SetSelfTokenID(testTokenId);
77
78 CreateOptions options;
79 options.enabled_ = true;
80 dataShareHelper = DataShare::DataShareHelper::Creator(DATA_SHARE_PROXY_URI, options);
81 ASSERT_TRUE(dataShareHelper != nullptr);
82 dataShareHelper2 = DataShare::DataShareHelper::Creator(DATA_SHARE_PROXY_URI, options);
83 ASSERT_TRUE(dataShareHelper2 != nullptr);
84 LOG_INFO("SetUpTestCase end");
85 }
86
TearDownTestCase(void)87 void ProxyDatasTest::TearDownTestCase(void)
88 {
89 auto tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.datashareclienttest.demo", 0);
90 AccessTokenKit::DeleteToken(tokenId);
91 dataShareHelper = nullptr;
92 dataShareHelper2 = nullptr;
93 }
94
SetUp(void)95 void ProxyDatasTest::SetUp(void)
96 {
97 }
TearDown(void)98 void ProxyDatasTest::TearDown(void)
99 {
100 }
101
102 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Insert_Test_001, TestSize.Level1)
103 {
104 LOG_INFO("ProxyDatasTest_Insert_Test_001::Start");
105 auto helper = dataShareHelper;
106 Uri uri(DATA_SHARE_PROXY_URI);
107 DataShare::DataShareValuesBucket valuesBucket;
108 std::string name0 = "wang";
109 valuesBucket.Put(TBL_NAME0, name0);
110 std::string name1 = "wu";
111 valuesBucket.Put(TBL_NAME1, name1);
112
113 int retVal = helper->Insert(uri, valuesBucket);
114 EXPECT_EQ((retVal > 0), true);
115 LOG_INFO("ProxyDatasTest_Insert_Test_001::End");
116 }
117
118 HWTEST_F(ProxyDatasTest, ProxyDatasTest_QUERY_Test_001, TestSize.Level1)
119 {
120 LOG_INFO("ProxyDatasTest_QUERY_Test_001::Start");
121 auto helper = dataShareHelper;
122 Uri uri(DATA_SHARE_PROXY_URI);
123 DataShare::DataSharePredicates predicates;
124 predicates.EqualTo(TBL_NAME0, "wang");
125 std::vector<string> columns;
126 auto resultSet = helper->Query(uri, predicates, columns);
127 EXPECT_NE(resultSet, nullptr);
128 int result = 0;
129 resultSet->GetRowCount(result);
130 EXPECT_EQ(result, 1);
131 LOG_INFO("ProxyDatasTest_QUERY_Test_001::End");
132 }
133
134 HWTEST_F(ProxyDatasTest, ProxyDatasTest_ResultSet_Test_001, TestSize.Level1)
135 {
136 LOG_INFO("ProxyDatasTest_ResultSet_Test_001::Start");
137 auto helper = dataShareHelper;
138 Uri uri(DATA_SHARE_PROXY_URI);
139 DataShare::DataSharePredicates predicates;
140 predicates.EqualTo(TBL_NAME0, "wang");
141 std::vector<string> columns;
142 auto resultSet = helper->Query(uri, predicates, columns);
143 EXPECT_NE(resultSet, nullptr);
144 int result = 0;
145 resultSet->GetRowCount(result);
146 EXPECT_EQ(result, 1);
147
148 bool hasBlock = resultSet->HasBlock();
149 EXPECT_EQ(hasBlock, true);
150 EXPECT_NE(resultSet->GetBlock(), nullptr);
151
152 std::vector<uint8_t> blob;
153 int err = resultSet->GetBlob(-1, blob);
154 EXPECT_EQ(err, E_INVALID_COLUMN_INDEX);
155 resultSet->SetBlock(nullptr);
156 EXPECT_EQ(nullptr, resultSet->GetBlock());
157 std::string stringValue;
158 result = resultSet->GetString(0, stringValue);
159 EXPECT_EQ(result, E_ERROR);
160 int intValue;
161 result = resultSet->GetInt(0, intValue);
162 EXPECT_EQ(result, E_ERROR);
163 LOG_INFO("ProxyDatasTest_ResultSet_Test_001::End");
164 }
165
166 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Template_Test_001, TestSize.Level1)
167 {
168 LOG_INFO("ProxyDatasTest_Template_Test_001::Start");
169 auto helper = dataShareHelper;
170 PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
171 PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
172 std::vector<PredicateTemplateNode> nodes;
173 nodes.emplace_back(node1);
174 nodes.emplace_back(node2);
175 Template tpl(nodes, "select name1 as name from TBL00");
176
177 auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
178 EXPECT_EQ(result, 0);
179 result = helper->DelQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID);
180 EXPECT_EQ(result, 0);
181 LOG_INFO("ProxyDatasTest_Template_Test_001::End");
182 }
183
184 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Template_Test_002, TestSize.Level1)
185 {
186 LOG_INFO("ProxyDatasTest_Template_Test_002::Start");
187 auto helper = dataShareHelper;
188 PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
189 PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
190 std::vector<PredicateTemplateNode> nodes;
191 nodes.emplace_back(node1);
192 nodes.emplace_back(node2);
193 Template tpl(nodes, "select name1 as name from TBL00");
194
195 std::string errorUri = "datashareproxy://com.acts.ohos.data.datasharetest";
196 auto result = helper->AddQueryTemplate(errorUri, SUBSCRIBER_ID, tpl);
197 EXPECT_EQ(result, E_URI_NOT_EXIST);
198 result = helper->DelQueryTemplate(errorUri, SUBSCRIBER_ID);
199 EXPECT_EQ(result, E_URI_NOT_EXIST);
200 LOG_INFO("ProxyDatasTest_Template_Test_002::End");
201 }
202
203 /**
204 * @tc.name: ProxyDatasTest_Template_Test_003
205 * @tc.desc: test Template update function
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Template_Test_003, TestSize.Level1)
210 {
211 LOG_INFO("ProxyDatasTest_Template_Test_003::Start");
212 auto helper = dataShareHelper;
213 PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
214 std::vector<PredicateTemplateNode> nodes;
215 nodes.emplace_back(node1);
216 Template tpl(nodes, "select name0 as name from TBL00");
217 tpl.update_ = "update TBL00 set name0 = 'updatetest' where name0 = 'name00'";
218 auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
219 EXPECT_EQ(result, 0);
220
221 std::vector<std::string> uris;
222 uris.emplace_back(DATA_SHARE_PROXY_URI);
223 TemplateId tplId;
224 tplId.subscriberId_ = SUBSCRIBER_ID;
225 tplId.bundleName_ = "ohos.datashareproxyclienttest.demo";
226 std::string data1;
227 std::vector<OperationResult> results1 =
__anon0087130f0102(const RdbChangeNode &changeNode) 228 helper->SubscribeRdbData(uris, tplId, [&data1](const RdbChangeNode &changeNode) {
229 data1 = changeNode.data_[0];
230 });
231 for (auto const &operationResult : results1) {
232 EXPECT_EQ(operationResult.errCode_, 0);
233 }
234
235 Uri uri(DATA_SHARE_PROXY_URI);
236 DataShare::DataShareValuesBucket valuesBucket;
237 std::string name0 = "name00";
238 valuesBucket.Put(TBL_NAME0, name0);
239 int retVal = helper->Insert(uri, valuesBucket);
240 EXPECT_GT(retVal, 0);
241
242 DataShare::DataSharePredicates predicates;
243 predicates.EqualTo(TBL_NAME0, "updatetest");
244 std::vector<string> columns;
245 auto resultSet = helper->Query(uri, predicates, columns);
246 EXPECT_NE(resultSet, nullptr);
247 int queryResult = 0;
248 resultSet->GetRowCount(queryResult);
249 EXPECT_EQ(queryResult, 1);
250
251 std::vector<OperationResult> results2 = helper->UnsubscribeRdbData(uris, tplId);
252 EXPECT_EQ(results2.size(), uris.size());
253 for (auto const &operationResult : results2) {
254 EXPECT_EQ(operationResult.errCode_, 0);
255 }
256 LOG_INFO("ProxyDatasTest_Template_Test_003::End");
257 }
258
259 /**
260 * @tc.name: ProxyDatasTest_Template_Test_004
261 * @tc.desc: test add template with parameter update function
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Template_Test_004, TestSize.Level1)
266 {
267 LOG_INFO("ProxyDatasTest_Template_Test_004::Start");
268 auto helper = dataShareHelper;
269 PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
270 PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
271 std::vector<PredicateTemplateNode> nodes;
272 nodes.emplace_back(node1);
273 nodes.emplace_back(node2);
274 Template tpl(nodes, "select name1 as name from TBL00");
275
276 auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
277 EXPECT_EQ(result, 0);
278 result = helper->DelQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID);
279 EXPECT_EQ(result, 0);
280
281 Template tpl2("update TBL00 set name0 = 'update'", nodes, "select name1 as name from TBL00");
282 result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl2);
283 EXPECT_EQ(result, 0);
284 result = helper->DelQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID);
285 EXPECT_EQ(result, 0);
286 LOG_INFO("ProxyDatasTest_Template_Test_004::End");
287 }
288
289 /**
290 * @tc.name: ProxyDatasTest_Template_Test_005
291 * @tc.desc: test add template with wrong parameter update function
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Template_Test_005, TestSize.Level1)
296 {
297 LOG_INFO("ProxyDatasTest_Template_Test_005::Start");
298 auto helper = dataShareHelper;
299 PredicateTemplateNode node1("p1", "select name0 as name from TBL00");
300 PredicateTemplateNode node2("p2", "select name1 as name from TBL00");
301 std::vector<PredicateTemplateNode> nodes;
302 nodes.emplace_back(node1);
303 nodes.emplace_back(node2);
304 Template tpl2("insert into TBL00 (name0) values ('test')", nodes, "select name1 as name from TBL00");
305
306 auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl2);
307 EXPECT_EQ(result, -1);
308 result = helper->DelQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID);
309 EXPECT_EQ(result, 0);
310 LOG_INFO("ProxyDatasTest_Template_Test_005::End");
311 }
312
313 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Publish_Test_001, TestSize.Level1)
314 {
315 LOG_INFO("ProxyDatasTest_Publish_Test_001::Start");
316 auto helper = dataShareHelper;
317 std::string bundleName = "com.acts.ohos.data.datasharetest";
318 Data data;
319 data.datas_.emplace_back("datashareproxy://com.acts.ohos.data.datasharetest/test", SUBSCRIBER_ID, "value1");
320 std::vector<OperationResult> results = helper->Publish(data, bundleName);
321 EXPECT_EQ(results.size(), data.datas_.size());
322 for (auto const &result : results) {
323 EXPECT_EQ(result.errCode_, 0);
324 }
325
326 int errCode = 0;
327 auto getData = helper->GetPublishedData(bundleName, errCode);
328 EXPECT_EQ(errCode, 0);
329 EXPECT_EQ(getData.datas_.size(), data.datas_.size());
330 for (auto &publishedDataItem : getData.datas_) {
331 EXPECT_EQ(publishedDataItem.subscriberId_, SUBSCRIBER_ID);
332 bool isString = publishedDataItem.IsString();
333 EXPECT_EQ(isString, true);
334 EXPECT_EQ(publishedDataItem.key_, "datashareproxy://com.acts.ohos.data.datasharetest/test");
335 auto value = publishedDataItem.GetData();
336 EXPECT_EQ(std::get<std::string>(value), "value1");
337 }
338 LOG_INFO("ProxyDatasTest_Publish_Test_001::End");
339 }
340
341 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Publish_Test_002, TestSize.Level1)
342 {
343 LOG_INFO("ProxyDatasTest_Publish_Test_002::Start");
344 auto helper = dataShareHelper;
345 std::string bundleName = "com.acts.ohos.error";
346 Data data;
347 data.datas_.emplace_back("datashareproxy://com.acts.ohos.error", SUBSCRIBER_ID, "value1");
348 std::vector<OperationResult> results = helper->Publish(data, bundleName);
349 EXPECT_EQ(results.size(), data.datas_.size());
350 for (auto const &result : results) {
351 EXPECT_EQ(result.errCode_, E_BUNDLE_NAME_NOT_EXIST);
352 }
353
354 int errCode = 0;
355 auto getData = helper->GetPublishedData(bundleName, errCode);
356 EXPECT_EQ(errCode, E_BUNDLE_NAME_NOT_EXIST);
357 LOG_INFO("ProxyDatasTest_Publish_Test_002::End");
358 }
359
360 HWTEST_F(ProxyDatasTest, ProxyDatasTest_Publish_Test_003, TestSize.Level1)
361 {
362 LOG_INFO("ProxyDatasTest_Publish_Test_003::Start");
363 auto helper = dataShareHelper;
364 Data data;
365 std::vector<uint8_t> buffer= {10, 20, 30};
366 data.datas_.emplace_back("datashareproxy://com.acts.ohos.data.datasharetest/test", SUBSCRIBER_ID, buffer);
367 std::string bundleName = "com.acts.ohos.data.datasharetest";
368 std::vector<OperationResult> results = helper->Publish(data, bundleName);
369 EXPECT_EQ(results.size(), data.datas_.size());
370 for (auto const &result : results) {
371 EXPECT_EQ(result.errCode_, 0);
372 }
373
374 int errCode = 0;
375 auto getData = helper->GetPublishedData(bundleName, errCode);
376 EXPECT_EQ(errCode, 0);
377 EXPECT_EQ(getData.datas_.size(), data.datas_.size());
378 for (auto &publishedDataItem : getData.datas_) {
379 EXPECT_EQ(publishedDataItem.subscriberId_, SUBSCRIBER_ID);
380 bool isAshmem = publishedDataItem.IsAshmem();
381 EXPECT_TRUE(isAshmem);
382 auto value = publishedDataItem.GetData();
383 EXPECT_EQ(std::get<std::vector<uint8_t>>(value)[0], buffer[0]);
384 }
385 LOG_INFO("ProxyDatasTest_Publish_Test_003::End");
386 }
387
388 HWTEST_F(ProxyDatasTest, ProxyDatasTest_CombinationRdbData_Test_001, TestSize.Level1)
389 {
390 LOG_INFO("ProxyDatasTest_CombinationRdbData_Test_001::Start");
391 auto helper = dataShareHelper;
392 PredicateTemplateNode node("p1", "select name0 as name from TBL00");
393 std::vector<PredicateTemplateNode> nodes;
394 nodes.emplace_back(node);
395 Template tpl(nodes, "select name1 as name from TBL00");
396 auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
397 EXPECT_EQ(result, 0);
398 std::vector<std::string> uris;
399 uris.emplace_back(DATA_SHARE_PROXY_URI);
400 TemplateId tplId;
401 tplId.subscriberId_ = SUBSCRIBER_ID;
402 tplId.bundleName_ = "ohos.datashareproxyclienttest.demo";
403 std::vector<OperationResult> results1 =
__anon0087130f0202(const RdbChangeNode &changeNode) 404 helper->SubscribeRdbData(uris, tplId, [&tplId](const RdbChangeNode &changeNode) {
405 EXPECT_EQ(changeNode.uri_, DATA_SHARE_PROXY_URI);
406 EXPECT_EQ(changeNode.templateId_.bundleName_, tplId.bundleName_);
407 EXPECT_EQ(changeNode.templateId_.subscriberId_, tplId.subscriberId_);
408 g_callbackTimes++;
409 });
410 EXPECT_EQ(results1.size(), uris.size());
411 for (auto const &operationResult : results1) {
412 EXPECT_EQ(operationResult.errCode_, 0);
413 }
414
415 std::vector<OperationResult> results3 = helper->EnableRdbSubs(uris, tplId);
416 for (auto const &operationResult : results3) {
417 EXPECT_EQ(operationResult.errCode_, 0);
418 }
419 Uri uri(DATA_SHARE_PROXY_URI);
420 DataShare::DataShareValuesBucket valuesBucket1, valuesBucket2;
421 std::string name1 = "wu";
422 std::string name2 = "liu";
423 valuesBucket1.Put(TBL_NAME1, name1);
424 int retVal1 = helper->Insert(uri, valuesBucket1);
425 EXPECT_EQ((retVal1 > 0), true);
426 EXPECT_EQ(g_callbackTimes, 2);
427 std::vector<OperationResult> results4 = helper->UnsubscribeRdbData(uris, tplId);
428 EXPECT_EQ(results4.size(), uris.size());
429 for (auto const &operationResult : results4) {
430 EXPECT_EQ(operationResult.errCode_, 0);
431 }
432 valuesBucket2.Put(TBL_NAME1, name2);
433 int retVal2 = helper->Insert(uri, valuesBucket2);
434 EXPECT_EQ((retVal2 > 0), true);
435 EXPECT_EQ(g_callbackTimes, 2);
436 LOG_INFO("ProxyDatasTest_CombinationRdbData_Test_001::End");
437 }
438
439 /**
440 * @tc.name: ProxyDatasTest_CombinationRdbData_Test_002
441 * @tc.desc: combination test for persistent data updated between two constant disable
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(ProxyDatasTest, ProxyDatasTest_CombinationRdbData_Test_002, TestSize.Level1)
446 {
447 auto helper = dataShareHelper;
448 auto helper2 = dataShareHelper2;
449 std::vector<PredicateTemplateNode> nodes;
450 Template tpl(nodes, "select name1 as name from TBL00");
451 auto result = helper->AddQueryTemplate(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, tpl);
452 EXPECT_EQ(result, 0);
453
454 std::vector<std::string> uris = {DATA_SHARE_PROXY_URI};
455 TemplateId tplId;
456 tplId.subscriberId_ = SUBSCRIBER_ID;
457 tplId.bundleName_ = "ohos.datashareproxyclienttest.demo";
458 std::atomic_int callbackTimes = 0;
459 std::mutex mutex;
460 std::condition_variable cv;
461 auto timeout = std::chrono::seconds(2);
462 std::vector<OperationResult> results =
__anon0087130f0302(const RdbChangeNode &changeNode) 463 helper->SubscribeRdbData(uris, tplId, [&callbackTimes, &mutex, &cv](const RdbChangeNode &changeNode) {
464 std::lock_guard<std::mutex> lock(mutex);
465 callbackTimes++;
466 cv.notify_all();
467 });
468 EXPECT_EQ(results.size(), uris.size());
469 for (auto const &result : results) EXPECT_EQ(result.errCode_, 0);
470 // if there is only one subscriber in a key, the subscriber can't be disabled twice
__anon0087130f0402(const RdbChangeNode &changeNode) 471 results = helper2->SubscribeRdbData(uris, tplId, [](const RdbChangeNode &changeNode) {
472 });
473
474 std::unique_lock<std::mutex> lock(mutex);
475 cv.wait_for(lock, timeout);
476 EXPECT_EQ(callbackTimes, 1);
477 lock.unlock();
478 results = helper->DisableRdbSubs(uris, tplId);
479 EXPECT_EQ(results.size(), uris.size());
480 for (auto const &result : results) EXPECT_EQ(result.errCode_, 0);
481
482 Uri uri(DATA_SHARE_PROXY_URI);
483 DataShare::DataShareValuesBucket valuesBucket;
484 valuesBucket.Put(TBL_NAME1, 1);
485 int retVal = helper->Insert(uri, valuesBucket);
486 EXPECT_GT(retVal, 0);
487
488 results = helper->DisableRdbSubs(uris, tplId);
489 EXPECT_EQ(results.size(), uris.size());
490 for (auto const &result : results) EXPECT_EQ(result.errCode_, 0);
491 results = helper->EnableRdbSubs(uris, tplId);
492 for (auto const &result : results) EXPECT_EQ(result.errCode_, 0);
493 EXPECT_EQ(callbackTimes, 2);
494 helper->UnsubscribeRdbData(uris, tplId);
495 helper2->UnsubscribeRdbData(uris, tplId);
496 }
497
498 /**
499 * @tc.name: ProxyDatasTest_CombinationPublishedData_Test_001
500 * @tc.desc: combination test for published data updated between two constant disable
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(ProxyDatasTest, ProxyDatasTest_CombinationPublishedData_Test_001, TestSize.Level1)
505 {
506 LOG_INFO("ProxyDatasTest_CombinationPublishedData_Test_001::Start");
507 auto helper = dataShareHelper;
508 auto helper2 = dataShareHelper2;
509 std::string bundleName = "com.acts.ohos.data.datasharetest";
510 Data data;
511 data.datas_.emplace_back(DATA_SHARE_PROXY_URI, SUBSCRIBER_ID, "value1");
512 std::vector<OperationResult> results = helper->Publish(data, bundleName);
513 EXPECT_EQ(results.size(), data.datas_.size());
514 for (auto const &result : results) EXPECT_EQ(result.errCode_, 0);
515 std::vector<std::string> uris = {DATA_SHARE_PROXY_URI};
516 std::atomic_int callbackTimes = 0;
517 std::mutex mutex;
518 std::condition_variable cv;
519 auto timeout = std::chrono::seconds(2);
520 results = helper->SubscribePublishedData(uris, SUBSCRIBER_ID,
__anon0087130f0502(const PublishedDataChangeNode &changeNode) 521 [&callbackTimes, &mutex, &cv](const PublishedDataChangeNode &changeNode) {
522 std::lock_guard<std::mutex> lock(mutex);
523 callbackTimes++;
524 cv.notify_all();
525 });
526 EXPECT_EQ(results.size(), uris.size());
527 for (auto const &operationResult : results) EXPECT_EQ(operationResult.errCode_, 0);
528 // if there is only one subscriber in a key, the subscriber can't be disabled twice
__anon0087130f0602(const PublishedDataChangeNode &changeNode) 529 results = helper2->SubscribePublishedData(uris, SUBSCRIBER_ID, [](const PublishedDataChangeNode &changeNode) {});
530 EXPECT_EQ(results.size(), uris.size());
531 for (auto const &operationResult : results) {
532 EXPECT_EQ(operationResult.errCode_, 0);
533 }
534 std::unique_lock<std::mutex> lock(mutex);
535 cv.wait_for(lock, timeout);
536 EXPECT_EQ(callbackTimes, 1);
537 lock.unlock();
538 results = helper->DisablePubSubs(uris, SUBSCRIBER_ID);
539 EXPECT_EQ(results.size(), uris.size());
540 for (auto const &operationResult : results) EXPECT_EQ(operationResult.errCode_, 0);
541
542 results = helper->Publish(data, bundleName);
543 EXPECT_EQ(results.size(), data.datas_.size());
544 for (auto const &result : results) EXPECT_EQ(result.errCode_, 0);
545 results = helper->DisablePubSubs(uris, SUBSCRIBER_ID);
546 for (auto const &operationResult : results) EXPECT_EQ(operationResult.errCode_, 0);
547 results = helper->EnablePubSubs(uris, SUBSCRIBER_ID);
548 for (auto const &operationResult : results) EXPECT_EQ(operationResult.errCode_, 0);
549 EXPECT_EQ(callbackTimes, 2);
550 helper->UnsubscribePublishedData(uris, SUBSCRIBER_ID);
551 helper2->UnsubscribePublishedData(uris, SUBSCRIBER_ID);
552 LOG_INFO("ProxyDatasTest_CombinationPublishedData_Test_001::End");
553 }
554
555 HWTEST_F(ProxyDatasTest, ProxyDatasTest_SubscribePublishedData_Test_001, TestSize.Level1)
556 {
557 LOG_INFO("ProxyDatasTest_SubscribePublishedData_Test_001::Start");
558 auto helper = dataShareHelper;
559 std::vector<std::string> uris;
560 uris.emplace_back(DATA_SHARE_PROXY_URI);
561 std::vector<OperationResult> results =
__anon0087130f0702(const PublishedDataChangeNode &changeNode) 562 helper->SubscribePublishedData(uris, SUBSCRIBER_ID, [](const PublishedDataChangeNode &changeNode) {
563 EXPECT_EQ(changeNode.ownerBundleName_, "ohos.datashareproxyclienttest.demo");
564 });
565 EXPECT_EQ(results.size(), uris.size());
566 for (auto const &operationResult : results) {
567 EXPECT_EQ(operationResult.errCode_, 0);
568 }
569 LOG_INFO("ProxyDatasTest_SubscribePublishedData_Test_001::End");
570 }
571
572 HWTEST_F(ProxyDatasTest, ProxyDatasTest_DisablePubSubs_Test_001, TestSize.Level1)
573 {
574 LOG_INFO("ProxyDatasTest_DisablePubSubs_Test_001::Start");
575 auto helper = dataShareHelper;
576 std::vector<std::string> uris;
577 uris.emplace_back(DATA_SHARE_PROXY_URI);
578 std::vector<OperationResult> results = helper->DisablePubSubs(uris, SUBSCRIBER_ID);
579 for (auto const &operationResult : results) {
580 EXPECT_EQ(operationResult.errCode_, 0);
581 }
582 LOG_INFO("ProxyDatasTest_DisablePubSubs_Test_001::End");
583 }
584
585 HWTEST_F(ProxyDatasTest, ProxyDatasTest_EnablePubSubs_Test_001, TestSize.Level1)
586 {
587 LOG_INFO("ProxyDatasTest_EnablePubSubs_Test_001::Start");
588 auto helper = dataShareHelper;
589 std::vector<std::string> uris;
590 uris.emplace_back(DATA_SHARE_PROXY_URI);
591 std::vector<OperationResult> results = helper->EnablePubSubs(uris, SUBSCRIBER_ID);
592 for (auto const &operationResult : results) {
593 EXPECT_EQ(operationResult.errCode_, 0);
594 }
595 LOG_INFO("ProxyDatasTest_EnablePubSubs_Test_001::End");
596 }
597
598 HWTEST_F(ProxyDatasTest, ProxyDatasTest_UnsubscribePublishedData_Test_001, TestSize.Level1)
599 {
600 LOG_INFO("ProxyDatasTest_UnsubscribePublishedData_Test_001::Start");
601 auto helper = dataShareHelper;
602 std::vector<std::string> uris;
603 uris.emplace_back(DATA_SHARE_PROXY_URI);
604 std::vector<OperationResult> results = helper->UnsubscribePublishedData(uris, SUBSCRIBER_ID);
605 EXPECT_EQ(results.size(), uris.size());
606 for (auto const &operationResult : results) {
607 EXPECT_EQ(operationResult.errCode_, 0);
608 }
609 LOG_INFO("ProxyDatasTest_UnsubscribePublishedData_Test_001::End");
610 }
611
612 HWTEST_F(ProxyDatasTest, ProxyDatasTest_extSpCtl_Null_Test_001, TestSize.Level1)
613 {
614 LOG_INFO("ProxyDatasTest_extSpCtl_Null_Test_001::Start");
615 auto helper = dataShareHelper;
616 bool ret = helper->Release();
617 EXPECT_EQ(ret, true);
618 Uri uri("");
619 std::string str;
620 std::vector<std::string> result = helper->GetFileTypes(uri, str);
621 EXPECT_EQ(result.size(), 0);
622 int err = helper->OpenFile(uri, str);
623 EXPECT_EQ(err, -1);
624 err = helper->OpenRawFile(uri, str);
625 EXPECT_EQ(err, -1);
626 LOG_INFO("ProxyDatasTest_extSpCtl_Null_Test_001::End");
627 }
628
629 HWTEST_F(ProxyDatasTest, ProxyDatasTest_extSpCtl_Null_Test_002, TestSize.Level1)
630 {
631 LOG_INFO("ProxyDatasTest_extSpCtl_Null_Test_002::Start");
632 auto helper = dataShareHelper;
633 bool ret = helper->Release();
634 EXPECT_EQ(ret, true);
635 Uri uri("");
636 Uri uriResult = helper->NormalizeUri(uri);
637 EXPECT_EQ(uriResult, uri);
638 uriResult = helper->DenormalizeUri(uri);
639 EXPECT_EQ(uriResult, uri);
640 LOG_INFO("ProxyDatasTest_extSpCtl_Null_Test_002::End");
641 }
642 } // namespace DataShare
643 } // namespace OHOS