1 /*
2 * Copyright (C) 2021-2022 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 #include <vector>
18
19 #include "accesstoken_kit.h"
20 #include "data_ability_observer_stub.h"
21 #include "datashare_helper.h"
22 #include "datashare_log.h"
23 #include "hap_token_info.h"
24 #include "iservice_registry.h"
25 #include "system_ability_definition.h"
26 #include "token_setproc.h"
27
28 namespace OHOS {
29 namespace DataShare {
30 using namespace testing::ext;
31 using namespace OHOS::Security::AccessToken;
32 using ChangeInfo = DataShareObserver::ChangeInfo;
33 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
34 static int USER_100 = 100;
35 std::string DATA_SHARE_URI = "datashare:///com.acts.datasharetest";
36 std::string DATA_SHARE_ERROR_URI = "datashare:///com.acts.datasharetest000";
37 std::string SLIENT_ACCESS_URI = "datashare:///com.acts.datasharetest/entry/DB00/TBL00?Proxy=true";
38 std::string SLIENT_ERROR_URI = "datashare:///com.acts.datashare/entry/DB00/TBL00?Proxy=true";
39 std::string SLIENT_ERROR_DATABASE_URI = "datashare:///com.acts.datasharetest/entry/DB6666/TBL00?Proxy=true";
40 std::string SLIENT_REGISTER_URI = "datashare:///com.acts.datasharetest/entry/DB00/TBL02?Proxy=true";
41 std::string SLIENT_ACCESS_PERMISSION1_URI = "datashare:///com.acts.datasharetest/entry/DB00/permission1?Proxy=true";
42 std::string SLIENT_PROXY_PERMISSION1_URI = "datashareproxy://com.acts.datasharetest/entry/DB00/permission1";
43 std::string SLIENT_ACCESS_PERMISSION2_URI = "datashare:///com.acts.datasharetest/entry/DB00/permission2?Proxy=true";
44 std::string SLIENT_PROXY_PERMISSION2_URI = "datashareproxy://com.acts.datasharetest/entry/DB00/permission2";
45 std::string TBL_STU_NAME = "name";
46 std::string TBL_STU_AGE = "age";
47 std::shared_ptr<DataShare::DataShareHelper> g_slientAccessHelper;
48
49 template <typename T>
50 class ConditionLock {
51 public:
ConditionLock()52 explicit ConditionLock() {}
~ConditionLock()53 ~ConditionLock() {}
54 public:
Notify()55 void Notify()
56 {
57 std::lock_guard<std::mutex> lock(mutex_);
58 isSet_ = true;
59 cv_.notify_one();
60 }
61
Wait()62 void Wait()
63 {
64 std::unique_lock<std::mutex> lock(mutex_);
65 cv_.wait_for(lock, std::chrono::seconds(INTERVAL), [this]() { return isSet_; });
66 cv_.notify_one();
67 return;
68 }
69
Clear()70 void Clear()
71 {
72 std::lock_guard<std::mutex> lock(mutex_);
73 isSet_ = false;
74 cv_.notify_one();
75 }
76
77 private:
78 bool isSet_ = false;
79 T data_;
80 std::mutex mutex_;
81 std::condition_variable cv_;
82 static constexpr int64_t INTERVAL = 2;
83 };
84
85 class SlientAccessTest : public testing::Test {
86 public:
87 static void SetUpTestCase(void);
88 static void TearDownTestCase(void);
89 void SetUp();
90 void TearDown();
91 };
92
93 class IDataShareAbilityObserverTest : public AAFwk::DataAbilityObserverStub {
94 public:
95 IDataShareAbilityObserverTest() = default;
96
~IDataShareAbilityObserverTest()97 ~IDataShareAbilityObserverTest()
98 {}
99
OnChange()100 void OnChange()
101 {
102 name = "OnChangeName";
103 data.Notify();
104 }
105
GetName()106 std::string GetName()
107 {
108 return name;
109 }
110
SetName(std::string name)111 void SetName(std::string name)
112 {
113 this->name = name;
114 }
115
Clear()116 void Clear()
117 {
118 data.Clear();
119 }
120 ConditionLock<std::string> data;
121 private:
122 std::string name;
123 };
124
125 class DataShareObserverTest : public DataShare::DataShareObserver {
126 public:
DataShareObserverTest()127 DataShareObserverTest() {}
~DataShareObserverTest()128 ~DataShareObserverTest() {}
129
OnChange(const ChangeInfo & changeInfo)130 void OnChange(const ChangeInfo &changeInfo) override
131 {
132 changeInfo_ = changeInfo;
133 data.Notify();
134 }
135
Clear()136 void Clear()
137 {
138 changeInfo_.changeType_ = INVAILD;
139 changeInfo_.uris_.clear();
140 changeInfo_.data_ = nullptr;
141 changeInfo_.size_ = 0;
142 changeInfo_.valueBuckets_ = {};
143 data.Clear();
144 }
145
146 ChangeInfo changeInfo_;
147 ConditionLock<ChangeInfo> data;
148 };
149
CreateDataShareHelper(int32_t systemAbilityId,std::string uri)150 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId, std::string uri)
151 {
152 LOG_INFO("CreateDataShareHelper start");
153 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
154 if (saManager == nullptr) {
155 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
156 return nullptr;
157 }
158 auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
159 if (remoteObj == nullptr) {
160 LOG_ERROR("GetSystemAbility service failed.");
161 return nullptr;
162 }
163 return DataShare::DataShareHelper::Creator(remoteObj, uri);
164 }
165
GetPermissionStateFulls()166 std::vector<PermissionStateFull> GetPermissionStateFulls()
167 {
168 std::vector<PermissionStateFull> permissionStateFulls = {
169 {
170 .permissionName = "ohos.permission.WRITE_CONTACTS",
171 .isGeneral = true,
172 .resDeviceID = { "local" },
173 .grantStatus = { PermissionState::PERMISSION_GRANTED },
174 .grantFlags = { 1 }
175 },
176 {
177 .permissionName = "ohos.permission.WRITE_CALL_LOG",
178 .isGeneral = true,
179 .resDeviceID = { "local" },
180 .grantStatus = { PermissionState::PERMISSION_GRANTED },
181 .grantFlags = { 1 }
182 },
183 {
184 .permissionName = "ohos.permission.GET_BUNDLE_INFO",
185 .isGeneral = true,
186 .resDeviceID = { "local" },
187 .grantStatus = { PermissionState::PERMISSION_GRANTED },
188 .grantFlags = { 1 }
189 }
190 };
191 return permissionStateFulls;
192 }
193
SetUpTestCase(void)194 void SlientAccessTest::SetUpTestCase(void)
195 {
196 LOG_INFO("SetUpTestCase invoked");
197 auto dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, DATA_SHARE_URI);
198 ASSERT_TRUE(dataShareHelper != nullptr);
199 int sleepTime = 3;
200 sleep(sleepTime);
201
202 HapInfoParams info = {
203 .userID = 100,
204 .bundleName = "ohos.datashareclienttest.demo",
205 .instIndex = 0,
206 .appIDDesc = "ohos.datashareclienttest.demo"
207 };
208 auto permStateList = GetPermissionStateFulls();
209 HapPolicyParams policy = {
210 .apl = APL_NORMAL,
211 .domain = "test.domain",
212 .permList = {
213 {
214 .permissionName = "ohos.permission.test",
215 .bundleName = "ohos.datashareclienttest.demo",
216 .grantMode = 1,
217 .availableLevel = APL_NORMAL,
218 .label = "label",
219 .labelId = 1,
220 .description = "ohos.datashareclienttest.demo",
221 .descriptionId = 1
222 }
223 },
224 .permStateList = permStateList
225 };
226 AccessTokenKit::AllocHapToken(info, policy);
227 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
228 info.userID, info.bundleName, info.instIndex);
229 SetSelfTokenID(testTokenId.tokenIDEx);
230
231 g_slientAccessHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
232 ASSERT_TRUE(g_slientAccessHelper != nullptr);
233 LOG_INFO("SetUpTestCase end");
234 }
235
TearDownTestCase(void)236 void SlientAccessTest::TearDownTestCase(void)
237 {
238 auto tokenId = AccessTokenKit::GetHapTokenIDEx(100, "ohos.datashareclienttest.demo", 0);
239 AccessTokenKit::DeleteToken(tokenId.tokenIDEx);
240 g_slientAccessHelper = nullptr;
241 }
242
SetUp(void)243 void SlientAccessTest::SetUp(void) {}
TearDown(void)244 void SlientAccessTest::TearDown(void) {}
245
246 /**
247 * @tc.name: SlientAccess_Creator_Errorcode_Test_001
248 * @tc.desc: Test DataShareHelper creation with valid parameters
249 * @tc.type: FUNC
250 * @tc.require: NA
251 * @tc.precon: None
252 * @tc.step:
253 * 1. Get SystemAbilityManager instance
254 * 2. Get remote object for STORAGE_MANAGER_MANAGER_ID
255 * 3. Call DataShareHelper::Create() with valid remote object and URIs
256 * 4. Check return code and helper instance
257 * @tc.expect:
258 * 1. Return code is E_OK
259 * 2. Helper instance is not null
260 */
261 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_001, TestSize.Level0)
262 {
263 LOG_INFO("SlientAccess_Creator_Errorcode_Test_001::Start");
264 std::string uriStr1(SLIENT_ACCESS_URI);
265 std::string uriStr2 (DATA_SHARE_URI);
266 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
267 if (saManager == nullptr) {
268 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
269 }
270 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
271 if (remoteObj == nullptr) {
272 LOG_ERROR("GetSystemAbility service failed.");
273 }
274 auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
275 EXPECT_EQ(ret, DataShare::E_OK);
276 EXPECT_NE(helper, nullptr);
277 helper = nullptr;
278 LOG_INFO("SlientAccess_Creator_Errorcode_Test_001::End");
279 }
280
281 /**
282 * @tc.name: SlientAccess_Creator_Errorcode_Test_002
283 * @tc.desc: Test DataShareHelper creation with null remote object
284 * @tc.type: FUNC
285 * @tc.require: NA
286 * @tc.precon: None
287 * @tc.step:
288 * 1. Call DataShareHelper::Create() with null remote object and valid URIs
289 * 2. Check return code and helper instance
290 * @tc.expect:
291 * 1. Return code is E_TOKEN_EMPTY
292 * 2. Helper instance is null
293 */
294 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_002, TestSize.Level0)
295 {
296 LOG_INFO("SlientAccess_Creator_Errorcode_Test_002::Start");
297 std::string uriStr1(SLIENT_ACCESS_URI);
298 std::string uriStr2 (DATA_SHARE_URI);
299 auto [ret, helper] = DataShare::DataShareHelper::Create(nullptr, uriStr1, uriStr2);
300 EXPECT_EQ(ret, DataShare::E_TOKEN_EMPTY);
301 EXPECT_EQ(helper, nullptr);
302 LOG_INFO("SlientAccess_Creator_Errorcode_Test_002::End");
303 }
304
305 /**
306 * @tc.name: SlientAccess_Creator_Errorcode_Test_003
307 * @tc.desc: Test DataShareHelper creation with invalid URIs
308 * @tc.type: FUNC
309 * @tc.require: NA
310 * @tc.precon: None
311 * @tc.step:
312 * 1. Get SystemAbilityManager instance
313 * 2. Get remote object for STORAGE_MANAGER_MANAGER_ID
314 * 3. Call DataShareHelper::Create() with valid remote object, error URI and empty URI
315 * 4. Check return code and helper instance
316 * @tc.expect:
317 * 1. Return code is E_EXT_URI_INVALID
318 * 2. Helper instance is null
319 */
320 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_003, TestSize.Level0)
321 {
322 LOG_INFO("SlientAccess_Creator_Errorcode_Test_003::Start");
323 std::string uriStr1(SLIENT_ERROR_URI);
324 std::string uriStr2 ("");
325 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
326 if (saManager == nullptr) {
327 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
328 }
329 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
330 if (remoteObj == nullptr) {
331 LOG_ERROR("GetSystemAbility service failed.");
332 }
333 // slientUri is error bundle name, extUri is empty, slient access can't find the bundle name
334 auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
335 EXPECT_EQ(ret, DataShare::E_EXT_URI_INVALID);
336 EXPECT_EQ(helper, nullptr);
337 helper = nullptr;
338 LOG_INFO("SlientAccess_Creator_Errorcode_Test_003::End");
339 }
340
341 /**
342 * @tc.name: SlientAccess_Creator_Errorcode_Test_004
343 * @tc.desc: Test DataShareHelper creation with same valid URIs
344 * @tc.type: FUNC
345 * @tc.require: NA
346 * @tc.precon: None
347 * @tc.step:
348 * 1. Get SystemAbilityManager instance
349 * 2. Get remote object for STORAGE_MANAGER_MANAGER_ID
350 * 3. Call DataShareHelper::Create() with valid remote object and same URIs
351 * 4. Check return code and helper instance
352 * @tc.expect:
353 * 1. Return code is E_OK
354 * 2. Helper instance is not null
355 */
356 HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_004, TestSize.Level0)
357 {
358 LOG_INFO("SlientAccess_Creator_Errorcode_Test_004::Start");
359 std::string uriStr1(DATA_SHARE_URI);
360 std::string uriStr2 (DATA_SHARE_URI);
361 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
362 if (saManager == nullptr) {
363 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
364 }
365 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
366 if (remoteObj == nullptr) {
367 LOG_ERROR("GetSystemAbility service failed.");
368 }
369 auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
370 EXPECT_EQ(ret, DataShare::E_OK);
371 EXPECT_NE(helper, nullptr);
372 helper = nullptr;
373 LOG_INFO("SlientAccess_Creator_Errorcode_Test_004::End");
374 }
375
376 /**
377 * @tc.name: SlientAccess_InsertEx_Test_001
378 * @tc.desc: Test InsertEx operation with valid data
379 * @tc.type: FUNC
380 * @tc.require: NA
381 * @tc.precon: None
382 * @tc.step:
383 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
384 * 2. Call InsertEx() with SLIENT_ACCESS_URI and values bucket
385 * 3. Check error code and return value
386 * @tc.expect:
387 * 1. Error code is 0 (success)
388 * 2. Return value is greater than 0 (valid row ID)
389 */
390 HWTEST_F(SlientAccessTest, SlientAccess_InsertEx_Test_001, TestSize.Level0)
391 {
392 LOG_INFO("SlientAccess_InsertEx_Test_001::Start");
393 auto helper = g_slientAccessHelper;
394 Uri uri(SLIENT_ACCESS_URI);
395 DataShare::DataShareValuesBucket valuesBucket;
396 std::string value = "lisi";
397 valuesBucket.Put(TBL_STU_NAME, value);
398 int age = 25;
399 valuesBucket.Put(TBL_STU_AGE, age);
400
401 auto [errCode, retVal] = helper->InsertEx(uri, valuesBucket);
402 EXPECT_EQ((errCode == 0), true);
403 EXPECT_EQ((retVal > 0), true);
404 LOG_INFO("SlientAccess_InsertEx_Test_001::End");
405 }
406
407 /**
408 * @tc.name: SlientAccess_InsertEx_Test_002
409 * @tc.desc: Test base class InsertEx operation
410 * @tc.type: FUNC
411 * @tc.require: NA
412 * @tc.precon: None
413 * @tc.step:
414 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
415 * 2. Call base class InsertEx() with SLIENT_ACCESS_URI and values bucket
416 * 3. Check return pair
417 * @tc.expect: The return pair is (0, 0)
418 */
419 HWTEST_F(SlientAccessTest, SlientAccess_InsertEx_Test_002, TestSize.Level0)
420 {
421 LOG_INFO("SilentAccess_InsertEx_Test_002::Start");
422 auto helper = g_slientAccessHelper;
423 Uri uri(SLIENT_ACCESS_URI);
424 DataShare::DataShareValuesBucket valuesBucket;
425 std::string value = "lisi";
426 valuesBucket.Put(TBL_STU_NAME, value);
427 int age = 25;
428 valuesBucket.Put(TBL_STU_AGE, age);
429
430 EXPECT_EQ(helper->DataShareHelper::InsertEx(uri, valuesBucket), std::make_pair(0, 0));
431 LOG_INFO("SilentAccess_InsertEx_Test_002::End");
432 }
433
434 /**
435 * @tc.name: SlientAccess_UpdateEx_Test_001
436 * @tc.desc: Test UpdateEx operation with valid data
437 * @tc.type: FUNC
438 * @tc.require: NA
439 * @tc.precon: None
440 * @tc.step:
441 * 1. Prepare DataShareValuesBucket with update data (age=50)
442 * 2. Create DataSharePredicates to select record with name="lisi"
443 * 3. Call UpdateEx() with SLIENT_ACCESS_URI, predicates and values bucket
444 * 4. Check error code and return value
445 * @tc.expect:
446 * 1. Error code is 0 (success)
447 * 2. Return value is greater than 0 (number of affected rows)
448 */
449 HWTEST_F(SlientAccessTest, SlientAccess_UpdateEx_Test_001, TestSize.Level0)
450 {
451 LOG_INFO("SlientAccess_UpdateEx_Test_001::Start");
452 auto helper = g_slientAccessHelper;
453 Uri uri(SLIENT_ACCESS_URI);
454 DataShare::DataShareValuesBucket valuesBucket;
455 int value = 50;
456 valuesBucket.Put(TBL_STU_AGE, value);
457 DataShare::DataSharePredicates predicates;
458 std::string selections = TBL_STU_NAME + " = 'lisi'";
459 predicates.SetWhereClause(selections);
460 auto [errCode, retVal] = helper->UpdateEx(uri, predicates, valuesBucket);
461 EXPECT_EQ((errCode == 0), true);
462 EXPECT_EQ((retVal > 0), true);
463 LOG_INFO("SlientAccess_UpdateEx_Test_001::End");
464 }
465
466 /**
467 * @tc.name: SlientAccess_UpdateEx_Test_002
468 * @tc.desc: Test base class UpdateEx operation
469 * @tc.type: FUNC
470 * @tc.require: NA
471 * @tc.precon: None
472 * @tc.step:
473 * 1. Prepare DataShareValuesBucket with update data (age=50)
474 * 2. Create DataSharePredicates to select record with name="lisi"
475 * 3. Call base class UpdateEx() with SLIENT_ACCESS_URI, predicates and values bucket
476 * 4. Check return pair
477 * @tc.expect: The return pair is (0, 0)
478 */
479 HWTEST_F(SlientAccessTest, SlientAccess_UpdateEx_Test_002, TestSize.Level0)
480 {
481 LOG_INFO("SilentAccess_UpdateEx_Test_002::Start");
482 auto helper = g_slientAccessHelper;
483 Uri uri(SLIENT_ACCESS_URI);
484 DataShare::DataShareValuesBucket valuesBucket;
485 int value = 50;
486 valuesBucket.Put(TBL_STU_AGE, value);
487 DataShare::DataSharePredicates predicates;
488 std::string selections = TBL_STU_NAME + " = 'lisi'";
489 predicates.SetWhereClause(selections);
490
491 EXPECT_EQ(helper->DataShareHelper::UpdateEx(uri, predicates, valuesBucket), std::make_pair(0, 0));
492 LOG_INFO("SilentAccess_UpdateEx_Test_002::End");
493 }
494
495 /**
496 * @tc.name: SlientAccess_DeleteEx_Test_001
497 * @tc.desc: Test DeleteEx operation with valid parameters
498 * @tc.type: FUNC
499 * @tc.require: NA
500 * @tc.precon: None
501 * @tc.step:
502 * 1. Create DataSharePredicates to select record with name="lisi"
503 * 2. Call DeleteEx() with SLIENT_ACCESS_URI and predicates
504 * 3. Check error code and return value
505 * @tc.expect:
506 * 1. Error code is 0 (success)
507 * 2. Return value is greater than 0 (number of deleted rows)
508 */
509 HWTEST_F(SlientAccessTest, SlientAccess_DeleteEx_Test_001, TestSize.Level0)
510 {
511 LOG_INFO("SlientAccess_DeleteEx_Test_001::Start");
512 auto helper = g_slientAccessHelper;
513 Uri uri(SLIENT_ACCESS_URI);
514
515 DataShare::DataSharePredicates deletePredicates;
516 std::string selections = TBL_STU_NAME + " = 'lisi'";
517 deletePredicates.SetWhereClause(selections);
518 auto [errCode, retVal] = helper->DeleteEx(uri, deletePredicates);
519 EXPECT_EQ((errCode == 0), true);
520 EXPECT_EQ((retVal > 0), true);
521 LOG_INFO("SlientAccess_DeleteEx_Test_001::End");
522 }
523
524 /**
525 * @tc.name: SlientAccess_DeleteEx_Test_002
526 * @tc.desc: Test base class DeleteEx operation
527 * @tc.type: FUNC
528 * @tc.require: NA
529 * @tc.precon: None
530 * @tc.step:
531 * 1. Create DataSharePredicates to select record with name="lisi"
532 * 2. Call base class DeleteEx() with SLIENT_ACCESS_URI and predicates
533 * 3. Check return pair
534 * @tc.expect: The return pair is (0, 0)
535 */
536 HWTEST_F(SlientAccessTest, SlientAccess_DeleteEx_Test_002, TestSize.Level0)
537 {
538 LOG_INFO("SilentAccess_DeleteEx_Test_002::Start");
539 auto helper = g_slientAccessHelper;
540 Uri uri(SLIENT_ACCESS_URI);
541 DataShare::DataSharePredicates deletePredicates;
542 std::string selections = TBL_STU_NAME + " = 'lisi'";
543 deletePredicates.SetWhereClause(selections);
544
545 EXPECT_EQ(helper->DataShareHelper::DeleteEx(uri, deletePredicates), std::make_pair(0, 0));
546 LOG_INFO("SilentAccess_DeleteEx_Test_002::End");
547 }
548
549 /**
550 * @tc.name: SlientAccess_Insert_Test_001
551 * @tc.desc: Test Insert operation with valid data
552 * @tc.type: FUNC
553 * @tc.require: NA
554 * @tc.precon: None
555 * @tc.step:
556 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
557 * 2. Call Insert() with SLIENT_ACCESS_URI and values bucket
558 * 3. Check return value
559 * @tc.expect: Return value is greater than 0 (valid row ID)
560 */
561 HWTEST_F(SlientAccessTest, SlientAccess_Insert_Test_001, TestSize.Level0)
562 {
563 LOG_INFO("SlientAccess_Insert_Test_001::Start");
564 auto helper = g_slientAccessHelper;
565 Uri uri(SLIENT_ACCESS_URI);
566 DataShare::DataShareValuesBucket valuesBucket;
567 std::string value = "lisi";
568 valuesBucket.Put(TBL_STU_NAME, value);
569 int age = 25;
570 valuesBucket.Put(TBL_STU_AGE, age);
571
572 int retVal = helper->Insert(uri, valuesBucket);
573 EXPECT_EQ((retVal > 0), true);
574 LOG_INFO("SlientAccess_Insert_Test_001::End");
575 }
576
577 /**
578 * @tc.name: SlientAccess_Update_Test_001
579 * @tc.desc: Test Update operation with valid data
580 * @tc.type: FUNC
581 * @tc.require: NA
582 * @tc.precon: None
583 * @tc.step:
584 * 1. Prepare DataShareValuesBucket with update data (age=50)
585 * 2. Create DataSharePredicates to select record with name="lisi"
586 * 3. Call Update() with SLIENT_ACCESS_URI, predicates and values bucket
587 * 4. Check return value
588 * @tc.expect: Return value is greater than 0 (number of affected rows)
589 */
590 HWTEST_F(SlientAccessTest, SlientAccess_Update_Test_001, TestSize.Level0)
591 {
592 LOG_INFO("SlientAccess_Update_Test_001::Start");
593 auto helper = g_slientAccessHelper;
594 Uri uri(SLIENT_ACCESS_URI);
595 DataShare::DataShareValuesBucket valuesBucket;
596 int value = 50;
597 valuesBucket.Put(TBL_STU_AGE, value);
598 DataShare::DataSharePredicates predicates;
599 std::string selections = TBL_STU_NAME + " = 'lisi'";
600 predicates.SetWhereClause(selections);
601 int retVal = helper->Update(uri, predicates, valuesBucket);
602 EXPECT_EQ((retVal > 0), true);
603 LOG_INFO("SlientAccess_Update_Test_001::End");
604 }
605
606 /**
607 * @tc.name: SlientAccess_Query_Test_001
608 * @tc.desc: Test Query operation with valid parameters
609 * @tc.type: FUNC
610 * @tc.require: NA
611 * @tc.precon: None
612 * @tc.step:
613 * 1. Create DataSharePredicates to select record with name="lisi"
614 * 2. Call Query() with SLIENT_ACCESS_URI, predicates and empty columns list
615 * 3. Check row count of the result set
616 * @tc.expect: Query returns 1 record
617 */
618 HWTEST_F(SlientAccessTest, SlientAccess_Query_Test_001, TestSize.Level0)
619 {
620 LOG_INFO("SlientAccess_Query_Test_001::Start");
621 auto helper = g_slientAccessHelper;
622 Uri uri(SLIENT_ACCESS_URI);
623 DataShare::DataSharePredicates predicates;
624 predicates.EqualTo(TBL_STU_NAME, "lisi");
625 vector<string> columns;
626 auto resultSet = helper->Query(uri, predicates, columns);
627 int result = 0;
628 if (resultSet != nullptr) {
629 resultSet->GetRowCount(result);
630 }
631 EXPECT_EQ(result, 1);
632 LOG_INFO("SlientAccess_Query_Test_001::End");
633 }
634
635 /**
636 * @tc.name: SlientAccess_Delete_Test_001
637 * @tc.desc: Test Delete operation with valid parameters
638 * @tc.type: FUNC
639 * @tc.require: NA
640 * @tc.precon: None
641 * @tc.step:
642 * 1. Create DataSharePredicates to select record with name="lisi"
643 * 2. Call Delete() with SLIENT_ACCESS_URI and predicates
644 * 3. Check return value
645 * @tc.expect: Return value is greater than 0 (number of deleted rows)
646 */
647 HWTEST_F(SlientAccessTest, SlientAccess_Delete_Test_001, TestSize.Level0)
648 {
649 LOG_INFO("SlientAccess_Delete_Test_001::Start");
650 auto helper = g_slientAccessHelper;
651 Uri uri(SLIENT_ACCESS_URI);
652
653 DataShare::DataSharePredicates deletePredicates;
654 std::string selections = TBL_STU_NAME + " = 'lisi'";
655 deletePredicates.SetWhereClause(selections);
656 int retVal = helper->Delete(uri, deletePredicates);
657 EXPECT_EQ((retVal > 0), true);
658 LOG_INFO("SlientAccess_Delete_Test_001::End");
659 }
660
661 /**
662 * @tc.name: SlientAccess_Register_Test_001
663 * @tc.desc: Test observer registration and notification in silent access mode
664 * @tc.type: FUNC
665 * @tc.require: NA
666 * @tc.precon: None
667 * @tc.step:
668 * 1. Create IDataShareAbilityObserverTest instance and set initial name "zhangsan"
669 * 2. Register observer with SLIENT_ACCESS_URI
670 * 3. Insert test data (name="lisi", age=25) using helper
671 * 4. Wait for observer notification
672 * 5. Verify observer name changes to "OnChangeName"
673 * 6. Delete test data and unregister observer
674 * @tc.expect:
675 * 1. Insert operation succeeds (retVal > 0)
676 * 2. Observer is notified and name updates to "OnChangeName"
677 * 3. Delete operation succeeds (retVal >= 0)
678 */
679 HWTEST_F(SlientAccessTest, SlientAccess_Register_Test_001, TestSize.Level0)
680 {
681 LOG_INFO("SlientAccess_Register_Test_001::Start");
682 auto helper = g_slientAccessHelper;
683 Uri uri(SLIENT_ACCESS_URI);
684 sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
685 dataObserver->SetName("zhangsan");
686 helper->RegisterObserver(uri, dataObserver);
687 EXPECT_EQ(dataObserver->GetName(), "zhangsan");
688 DataShare::DataShareValuesBucket valuesBucket;
689 std::string value = "lisi";
690 valuesBucket.Put(TBL_STU_NAME, value);
691 int age = 25;
692 valuesBucket.Put(TBL_STU_AGE, age);
693 int retVal = helper->Insert(uri, valuesBucket);
694 EXPECT_EQ((retVal > 0), true);
695 dataObserver->data.Wait();
696 EXPECT_EQ(dataObserver->GetName(), "OnChangeName");
697 dataObserver->Clear();
698
699 DataShare::DataSharePredicates deletePredicates;
700 deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
701 retVal = helper->Delete(uri, deletePredicates);
702 EXPECT_EQ((retVal >= 0), true);
703 helper->UnregisterObserver(uri, dataObserver);
704 LOG_INFO("SlientAccess_Register_Test_001::End");
705 }
706
707 /**
708 * @tc.name: SlientAccess_RegisterErrorUri_Test_001
709 * @tc.desc: Test observer registration with incorrect URI
710 * @tc.type: FUNC
711 * @tc.require: NA
712 * @tc.precon: None
713 * @tc.step:
714 * 1. Create IDataShareAbilityObserverTest instance and set name "zhangsan"
715 * 2. Register observer with incorrect URI (SLIENT_REGISTER_URI)
716 * 3. Insert test data (name="lisi", age=25) to SLIENT_ACCESS_URI
717 * 4. Check if observer is notified
718 * 5. Delete test data and unregister observer
719 * @tc.expect:
720 * 1. Insert operation succeeds (retVal > 0)
721 * 2. Observer is NOT notified (name remains "zhangsan")
722 * 3. Delete operation succeeds (retVal >= 0)
723 */
724 HWTEST_F(SlientAccessTest, SlientAccess_RegisterErrorUri_Test_001, TestSize.Level0)
725 {
726 LOG_INFO("SlientAccess_RegisterErrorUri_Test_001::Start");
727 auto helper = g_slientAccessHelper;
728 Uri uri(SLIENT_ACCESS_URI);
729 sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
730 dataObserver->SetName("zhangsan");
731 Uri uriRegister(SLIENT_REGISTER_URI);
732 helper->RegisterObserver(uriRegister, dataObserver);
733 EXPECT_EQ(dataObserver->GetName(), "zhangsan");
734 DataShare::DataShareValuesBucket valuesBucket;
735 std::string value = "lisi";
736 valuesBucket.Put(TBL_STU_NAME, value);
737 int age = 25;
738 valuesBucket.Put(TBL_STU_AGE, age);
739 int retVal = helper->Insert(uri, valuesBucket);
740 EXPECT_EQ((retVal > 0), true);
741 EXPECT_NE(dataObserver->GetName(), "OnChangeName");
742
743 DataShare::DataSharePredicates deletePredicates;
744 deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
745 retVal = helper->Delete(uri, deletePredicates);
746 EXPECT_EQ((retVal >= 0), true);
747 helper->UnregisterObserver(uriRegister, dataObserver);
748 LOG_INFO("SlientAccess_RegisterErrorUri_Test_001::End");
749 }
750
751 /**
752 * @tc.name: SlientAccess_NoRegister_Test_001
753 * @tc.desc: Test data operation without observer registration
754 * @tc.type: FUNC
755 * @tc.require: NA
756 * @tc.precon: None
757 * @tc.step:
758 * 1. Create IDataShareAbilityObserverTest instance but do NOT register it
759 * 2. Insert test data (name="lisi", age=25) using helper
760 * 3. Check if observer is notified
761 * 4. Delete test data
762 * @tc.expect:
763 * 1. Insert operation succeeds (retVal > 0)
764 * 2. Observer is NOT notified (name remains "zhangsan")
765 * 3. Delete operation succeeds (retVal >= 0)
766 */
767 HWTEST_F(SlientAccessTest, SlientAccess_NoRegister_Test_001, TestSize.Level0)
768 {
769 LOG_INFO("SlientAccess_NoRegister_Test_001::Start");
770 auto helper = g_slientAccessHelper;
771 Uri uri(SLIENT_ACCESS_URI);
772 sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
773 dataObserver->SetName("zhangsan");
774 EXPECT_EQ(dataObserver->GetName(), "zhangsan");
775 DataShare::DataShareValuesBucket valuesBucket;
776 std::string value = "lisi";
777 valuesBucket.Put(TBL_STU_NAME, value);
778 int age = 25;
779 valuesBucket.Put(TBL_STU_AGE, age);
780 int retVal = helper->Insert(uri, valuesBucket);
781 EXPECT_EQ((retVal > 0), true);
782 EXPECT_NE(dataObserver->GetName(), "OnChangeName");
783
784 DataShare::DataSharePredicates deletePredicates;
785 deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
786 retVal = helper->Delete(uri, deletePredicates);
787 EXPECT_EQ((retVal >= 0), true);
788 helper->UnregisterObserver(uri, dataObserver);
789 LOG_INFO("SlientAccess_NoRegister_Test_001::End");
790 }
791
792 /**
793 * @tc.name: SlientAccess_NoRegister_Test_002
794 * @tc.desc: Test data operation after unregistering observer
795 * @tc.type: FUNC
796 * @tc.require: NA
797 * @tc.precon: None
798 * @tc.step:
799 * 1. Create IDataShareAbilityObserverTest instance and register it
800 * 2. Immediately unregister the observer
801 * 3. Insert test data (name="lisi", age=25) using helper
802 * 4. Check if observer is notified
803 * 5. Delete test data
804 * @tc.expect:
805 * 1. Insert operation succeeds (retVal > 0)
806 * 2. Observer is NOT notified (name remains "zhangsan")
807 * 3. Delete operation succeeds (retVal >= 0)
808 */
809 HWTEST_F(SlientAccessTest, SlientAccess_NoRegister_Test_002, TestSize.Level0)
810 {
811 LOG_INFO("SlientAccess_NoRegister_Test_002::Start");
812 auto helper = g_slientAccessHelper;
813 Uri uri(SLIENT_ACCESS_URI);
814 sptr<IDataShareAbilityObserverTest> dataObserver(new (std::nothrow) IDataShareAbilityObserverTest());
815 dataObserver->SetName("zhangsan");
816 helper->RegisterObserver(uri, dataObserver);
817 helper->UnregisterObserver(uri, dataObserver);
818 EXPECT_EQ(dataObserver->GetName(), "zhangsan");
819 DataShare::DataShareValuesBucket valuesBucket;
820 std::string value = "lisi";
821 valuesBucket.Put(TBL_STU_NAME, value);
822 int age = 25;
823 valuesBucket.Put(TBL_STU_AGE, age);
824 int retVal = helper->Insert(uri, valuesBucket);
825 EXPECT_EQ((retVal > 0), true);
826 EXPECT_NE(dataObserver->GetName(), "OnChangeName");
827
828 DataShare::DataSharePredicates deletePredicates;
829 deletePredicates.EqualTo(TBL_STU_NAME, "lisi")->And()->EqualTo(TBL_STU_NAME, 25);
830 retVal = helper->Delete(uri, deletePredicates);
831 EXPECT_EQ((retVal >= 0), true);
832 LOG_INFO("SlientAccess_NoRegister_Test_002::End");
833 }
834
835 /**
836 * @tc.name: SlientAccess_Permission_Insert_Test_001
837 * @tc.desc: Test insert operation with proper permissions
838 * @tc.type: FUNC
839 * @tc.require: NA
840 * @tc.precon: None
841 * @tc.step:
842 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
843 * 2. Call Insert() with SLIENT_ACCESS_URI
844 * 3. Check return value
845 * @tc.expect: Insert operation succeeds (retVal > 0)
846 */
847 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Insert_Test_001, TestSize.Level0)
848 {
849 LOG_INFO("SlientAccess_Permission_Insert_Test_001::Start");
850 auto helper = g_slientAccessHelper;
851 Uri uri(SLIENT_ACCESS_URI);
852 DataShare::DataShareValuesBucket valuesBucket;
853 std::string value = "lisi";
854 valuesBucket.Put(TBL_STU_NAME, value);
855 int age = 25;
856 valuesBucket.Put(TBL_STU_AGE, age);
857
858 int retVal = helper->Insert(uri, valuesBucket);
859 EXPECT_EQ((retVal > 0), true);
860 LOG_INFO("SlientAccess_Permission_Insert_Test_001::End");
861 }
862
863 /**
864 * @tc.name: SlientAccess_Permission_Insert_Test_003
865 * @tc.desc: Test insert operation with proxy permission URI
866 * @tc.type: FUNC
867 * @tc.require: NA
868 * @tc.precon: None
869 * @tc.step:
870 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
871 * 2. Call Insert() with SLIENT_PROXY_PERMISSION1_URI
872 * 3. Check return value
873 * @tc.expect: Insert operation succeeds (retVal > 0)
874 */
875 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Insert_Test_003, TestSize.Level0)
876 {
877 LOG_INFO("SlientAccess_Permission_Insert_Test_003::Start");
878 auto helper = g_slientAccessHelper;
879 Uri uri(SLIENT_PROXY_PERMISSION1_URI);
880 DataShare::DataShareValuesBucket valuesBucket;
881 std::string value = "lisi";
882 valuesBucket.Put(TBL_STU_NAME, value);
883 int age = 25;
884 valuesBucket.Put(TBL_STU_AGE, age);
885
886 int retVal = helper->Insert(uri, valuesBucket);
887 EXPECT_EQ((retVal > 0), true);
888 LOG_INFO("SlientAccess_Permission_Insert_Test_003::End");
889 }
890
891 /**
892 * @tc.name: SlientAccess_Permission_Update_Test_001
893 * @tc.require: NA
894 * @tc.desc: Test update operation with proxy permission URI
895 * @tc.type: FUNC
896 * @tc.precon: None
897 * @tc.step:
898 * 1. Prepare DataShareValuesBucket with update data (age=50)
899 * 2. Create predicates to select record with name="lisi"
900 * 3. Call Update() with SLIENT_PROXY_PERMISSION1_URI
901 * 4. Check return value
902 * @tc.expect: Update operation succeeds (retVal > 0)
903 */
904 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Update_Test_001, TestSize.Level0)
905 {
906 LOG_INFO("SlientAccess_Permission_Update_Test_001::Start");
907 auto helper = g_slientAccessHelper;
908 Uri uri(SLIENT_PROXY_PERMISSION1_URI);
909 DataShare::DataShareValuesBucket valuesBucket;
910 int value = 50;
911 valuesBucket.Put(TBL_STU_AGE, value);
912 DataShare::DataSharePredicates predicates;
913 std::string selections = TBL_STU_NAME + " = 'lisi'";
914 predicates.SetWhereClause(selections);
915 int retVal = helper->Update(uri, predicates, valuesBucket);
916 EXPECT_EQ((retVal > 0), true);
917 LOG_INFO("SlientAccess_Permission_Update_Test_001::End");
918 }
919
920 /**
921 * @tc.name: SlientAccess_Permission_Query_Test_002
922 * @tc.desc: Test query operation with proxy permission URI
923 * @tc.type: FUNC
924 * @tc.require: NA
925 * @tc.precon: None
926 * @tc.step:
927 * 1. Insert test data (name="lisi", age=25) into SLIENT_PROXY_PERMISSION2_URI
928 * 2. Create predicates to select inserted record
929 * 3. Call Query() with SLIENT_PROXY_PERMISSION2_URI
930 * 4. Check result set row count and business error code
931 * @tc.expect:
932 * 1. Insert operation succeeds (retVal > 0)
933 * 2. Query returns 1 record
934 * 3. Business error code is 0 (no error)
935 */
936 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Query_Test_002, TestSize.Level0)
937 {
938 LOG_INFO("SlientAccess_Permission_Query_Test_002::Start");
939 auto helper = g_slientAccessHelper;
940 Uri uri(SLIENT_PROXY_PERMISSION2_URI);
941 DataShare::DataShareValuesBucket valuesBucket;
942 std::string value = "lisi";
943 valuesBucket.Put(TBL_STU_NAME, value);
944 int age = 25;
945 valuesBucket.Put(TBL_STU_AGE, age);
946
947 int retVal = helper->Insert(uri, valuesBucket);
948 EXPECT_EQ((retVal > 0), true);
949
950 DataShare::DataSharePredicates predicates;
951 predicates.EqualTo(TBL_STU_NAME, "lisi");
952 vector<string> columns;
953 DatashareBusinessError businessError;
954 auto resultSet = helper->Query(uri, predicates, columns, &businessError);
955 int result = 0;
956 if (resultSet != nullptr) {
957 resultSet->GetRowCount(result);
958 }
959 EXPECT_EQ(result, 1);
960 EXPECT_EQ(businessError.GetCode(), 0);
961 LOG_INFO("SlientAccess_Permission_Query_Test_002::End");
962 }
963
964 /**
965 * @tc.name: SlientAccess_Permission_Delete_Test_001
966 * @tc.desc: Test delete operation with proxy permission URI
967 * @tc.type: FUNC
968 * @tc.require: NA
969 * @tc.precon: None
970 * @tc.step:
971 * 1. Create predicates to select record with name="lisi"
972 * 2. Call Delete() with SLIENT_PROXY_PERMISSION2_URI
973 * 3. Check return value
974 * @tc.expect: Delete operation succeeds and deletes 1 record (retVal = 1)
975 */
976 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Delete_Test_001, TestSize.Level0)
977 {
978 LOG_INFO("SlientAccess_Permission_Delete_Test_001::Start");
979 auto helper = g_slientAccessHelper;
980 Uri uri(SLIENT_PROXY_PERMISSION2_URI);
981
982 DataShare::DataSharePredicates deletePredicates;
983 std::string selections = TBL_STU_NAME + " = 'lisi'";
984 deletePredicates.SetWhereClause(selections);
985 int retVal = helper->Delete(uri, deletePredicates);
986 EXPECT_EQ(retVal, 1);
987 LOG_INFO("SlientAccess_Permission_Delete_Test_001::End");
988 }
989
990 /**
991 * @tc.name: SlientAccess_Permission_Insert_Test_002
992 * @tc.desc: Test insert operation without required permissions
993 * @tc.type: FUNC
994 * @tc.require: NA
995 * @tc.precon: None
996 * @tc.step:
997 * 1. Create HAP token with limited permissions
998 * 2. Set token ID for current process
999 * 3. Create DataShareHelper instance
1000 * 4. Try to insert data into SLIENT_ACCESS_PERMISSION1_URI
1001 * 5. Clean up token
1002 * @tc.expect: Insert operation fails (retVal = -2)
1003 */
1004 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Insert_Test_002, TestSize.Level0)
1005 {
1006 LOG_INFO("SlientAccess_Permission_Insert_Test_002::Start");
1007 HapInfoParams info = {
1008 .userID = USER_100,
1009 .bundleName = "ohos.permission.write.demo",
1010 .instIndex = 0,
1011 .isSystemApp = true,
1012 .apiVersion = 8,
1013 .appIDDesc = "ohos.permission.write.demo"
1014 };
1015 HapPolicyParams policy = {
1016 .apl = APL_SYSTEM_CORE,
1017 .domain = "test.domain",
1018 .permStateList = {
1019 {
1020 .permissionName = "ohos.permission.WRITE_CONTACTS",
1021 .isGeneral = true,
1022 .resDeviceID = { "local" },
1023 .grantStatus = { PermissionState::PERMISSION_GRANTED },
1024 .grantFlags = { 1 }
1025 }
1026 }
1027 };
1028 AccessTokenKit::AllocHapToken(info, policy);
1029 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
1030 info.userID, info.bundleName, info.instIndex);
1031 SetSelfTokenID(testTokenId.tokenIDEx);
1032
1033 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
1034 Uri uri(SLIENT_ACCESS_PERMISSION1_URI);
1035 DataShare::DataShareValuesBucket valuesBucket;
1036 std::string value = "lisi";
1037 valuesBucket.Put(TBL_STU_NAME, value);
1038 int age = 25;
1039 valuesBucket.Put(TBL_STU_AGE, age);
1040 int retVal = helper->Insert(uri, valuesBucket);
1041 EXPECT_EQ(retVal, -2);
1042 helper = nullptr;
1043 AccessTokenKit::DeleteToken(testTokenId.tokenIDEx);
1044 LOG_INFO("SlientAccess_Permission_Insert_Test_002::End");
1045 }
1046
1047 /**
1048 * @tc.name: SlientAccess_Permission_Update_Test_002
1049 * @tc.desc: Test update operation without required permissions
1050 * @tc.type: FUNC
1051 * @tc.require: NA
1052 * @tc.precon: None
1053 * @tc.step:
1054 * 1. Create HAP token with limited permissions
1055 * 2. Set token ID for current process
1056 * 3. Create DataShareHelper instance
1057 * 4. Try to update data in SLIENT_ACCESS_PERMISSION1_URI
1058 * 5. Clean up token
1059 * @tc.expect: Update operation fails (retVal = -2)
1060 */
1061 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Update_Test_002, TestSize.Level0)
1062 {
1063 LOG_INFO("SlientAccess_Permission_Update_Test_002::Start");
1064 HapInfoParams info = {
1065 .userID = USER_100,
1066 .bundleName = "ohos.permission.write.demo",
1067 .instIndex = 0,
1068 .isSystemApp = true,
1069 .apiVersion = 8,
1070 .appIDDesc = "ohos.permission.write.demo"
1071 };
1072 HapPolicyParams policy = {
1073 .apl = APL_SYSTEM_CORE,
1074 .domain = "test.domain",
1075 .permStateList = {
1076 {
1077 .permissionName = "ohos.permission.WRITE_CONTACTS",
1078 .isGeneral = true,
1079 .resDeviceID = { "local" },
1080 .grantStatus = { PermissionState::PERMISSION_GRANTED },
1081 .grantFlags = { 1 }
1082 }
1083 }
1084 };
1085 AccessTokenKit::AllocHapToken(info, policy);
1086 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
1087 info.userID, info.bundleName, info.instIndex);
1088 SetSelfTokenID(testTokenId.tokenIDEx);
1089
1090 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
1091 Uri uri(SLIENT_ACCESS_PERMISSION1_URI);
1092 DataShare::DataShareValuesBucket valuesBucket;
1093 int value = 50;
1094 valuesBucket.Put(TBL_STU_AGE, value);
1095 DataShare::DataSharePredicates predicates;
1096 std::string selections = TBL_STU_NAME + " = 'lisi'";
1097 predicates.SetWhereClause(selections);
1098 int retVal = helper->Update(uri, predicates, valuesBucket);
1099 EXPECT_EQ(retVal, -2);
1100 helper = nullptr;
1101 AccessTokenKit::DeleteToken(testTokenId.tokenIDEx);
1102 LOG_INFO("SlientAccess_Permission_Update_Test_002::End");
1103 }
1104
1105 /**
1106 * @tc.name: SlientAccess_Permission_Query_Test_001
1107 * @tc.desc: Test query operation without required permissions
1108 * @tc.type: FUNC
1109 * @tc.require: NA
1110 * @tc.precon: None
1111 * @tc.step:
1112 * 1. Create HAP token with limited permissions (only WRITE_CONTACTS granted)
1113 * 2. Set token ID for current process
1114 * 3. Create DataShareHelper instance
1115 * 4. Try to query data from SLIENT_ACCESS_PERMISSION2_URI with predicates for "lisi"
1116 * 5. Check result set, row count and business error code
1117 * 6. Clean up token
1118 * @tc.expect:
1119 * 1. Result set is nullptr
1120 * 2. Row count is 0
1121 * 3. Business error code is -2 (permission denied)
1122 */
1123 HWTEST_F(SlientAccessTest, SlientAccess_Permission_Query_Test_001, TestSize.Level0)
1124 {
1125 LOG_INFO("SlientAccess_Permission_Query_Test_001::Start");
1126 HapInfoParams info = {
1127 .userID = USER_100,
1128 .bundleName = "ohos.permission.write.demo",
1129 .instIndex = 0,
1130 .isSystemApp = true,
1131 .apiVersion = 8,
1132 .appIDDesc = "ohos.permission.write.demo"
1133 };
1134 HapPolicyParams policy = {
1135 .apl = APL_SYSTEM_CORE,
1136 .domain = "test.domain",
1137 .permStateList = {
1138 {
1139 .permissionName = "ohos.permission.WRITE_CONTACTS",
1140 .isGeneral = true,
1141 .resDeviceID = { "local" },
1142 .grantStatus = { PermissionState::PERMISSION_GRANTED },
1143 .grantFlags = { 1 }
1144 }
1145 }
1146 };
1147 AccessTokenKit::AllocHapToken(info, policy);
1148 auto testTokenId = Security::AccessToken::AccessTokenKit::GetHapTokenIDEx(
1149 info.userID, info.bundleName, info.instIndex);
1150 SetSelfTokenID(testTokenId.tokenIDEx);
1151
1152 auto helper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, SLIENT_ACCESS_URI);
1153 Uri uri(SLIENT_ACCESS_PERMISSION2_URI);
1154 DataShare::DataSharePredicates predicates;
1155 predicates.EqualTo(TBL_STU_NAME, "lisi");
1156 vector<string> columns;
1157 DatashareBusinessError businessError;
1158 auto resultSet = helper->Query(uri, predicates, columns, &businessError);
1159 int result = 0;
1160 if (resultSet != nullptr) {
1161 resultSet->GetRowCount(result);
1162 }
1163 EXPECT_EQ(result, 0);
1164 EXPECT_EQ(resultSet, nullptr);
1165 EXPECT_EQ(businessError.GetCode(), -2);
1166 helper = nullptr;
1167 AccessTokenKit::DeleteToken(testTokenId.tokenIDEx);
1168 LOG_INFO("SlientAccess_Permission_Query_Test_001::End");
1169 }
1170
1171 /**
1172 * @tc.name: SlientAccess_Access_When_Uri_Error_Test_001
1173 * @tc.desc: Test data insertion with invalid URI
1174 * @tc.type: FUNC
1175 * @tc.require: NA
1176 * @tc.precon: None
1177 * @tc.step:
1178 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
1179 * 2. Call Insert() with invalid URI (SLIENT_ERROR_URI)
1180 * 3. Check return value
1181 * @tc.expect: Insert operation fails (retVal < 0)
1182 */
1183 HWTEST_F(SlientAccessTest, SlientAccess_Access_When_Uri_Error_Test_001, TestSize.Level0)
1184 {
1185 LOG_INFO("SlientAccess_Permission_Access_When_URI_ERROR_Test_001::Begin");
1186 auto helper = g_slientAccessHelper;
1187 Uri uri(SLIENT_ERROR_URI);
1188 DataShare::DataShareValuesBucket valuesBucket;
1189 std::string value = "lisi";
1190 valuesBucket.Put(TBL_STU_NAME, value);
1191 int age = 25;
1192 valuesBucket.Put(TBL_STU_AGE, age);
1193
1194 int retVal = helper->Insert(uri, valuesBucket);
1195 EXPECT_EQ((retVal < 0), true);
1196 LOG_INFO("SlientAccess_Permission_Access_When_URI_ERROR_Test_001::End");
1197 }
1198
1199 /**
1200 * @tc.name: SlientAccess_Access_With_Uncreated_DataBase_Test_001
1201 * @tc.desc: Test data insertion to uncreated database
1202 * @tc.type: FUNC
1203 * @tc.require: NA
1204 * @tc.precon: None
1205 * @tc.step:
1206 * 1. Prepare DataShareValuesBucket with test data (name="lisi", age=25)
1207 * 2. Call Insert() with URI pointing to uncreated database (SLIENT_ERROR_DATABASE_URI)
1208 * 3. Check return value
1209 * @tc.expect: Insert operation fails (retVal < 0)
1210 */
1211 HWTEST_F(SlientAccessTest, SlientAccess_Access_With_Uncreated_DataBase_Test_001, TestSize.Level0)
1212 {
1213 LOG_INFO("SlientAccess_Access_With_Uncreated_DataBase_Test_001::Begin");
1214 auto helper = g_slientAccessHelper;
1215 Uri uri(SLIENT_ERROR_DATABASE_URI);
1216 DataShare::DataShareValuesBucket valuesBucket;
1217 std::string value = "lisi";
1218 valuesBucket.Put(TBL_STU_NAME, value);
1219 int age = 25;
1220 valuesBucket.Put(TBL_STU_AGE, age);
1221
1222 int retVal = helper->Insert(uri, valuesBucket);
1223 EXPECT_EQ((retVal < 0), true);
1224 LOG_INFO("SlientAccess_Access_With_Uncreated_DataBase_Test_001::End");
1225 }
1226
1227 /**
1228 * @tc.name: SlientAccess_Creator_With_Uri_Error_Test_001
1229 * @tc.desc: Test DataShareHelper creation with invalid URI
1230 * @tc.type: FUNC
1231 * @tc.require: NA
1232 * @tc.precon: None
1233 * @tc.step:
1234 * 1. Get SystemAbilityManager instance and remote object for STORAGE_MANAGER_MANAGER_ID
1235 * 2. Try to create DataShareHelper with invalid URI (DATA_SHARE_ERROR_URI)
1236 * 3. Check helper instance
1237 * @tc.expect: Helper creation fails (helper == nullptr)
1238 */
1239 HWTEST_F(SlientAccessTest, SlientAccess_Creator_With_Uri_Error_Test_001, TestSize.Level0)
1240 {
1241 LOG_INFO("SlientAccess_Creator_With_Uri_Error_Test_001::Begin");
1242 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1243 if (saManager == nullptr) {
1244 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
1245 }
1246 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
1247 if (remoteObj == nullptr) {
1248 LOG_ERROR("GetSystemAbility service failed.");
1249 }
1250 std::string uriStr(DATA_SHARE_ERROR_URI);
1251 auto helper = DataShare::DataShareHelper::Creator(remoteObj, uriStr, uriStr, 2);
1252 EXPECT_EQ(helper, nullptr);
1253 LOG_INFO("SlientAccess_Creator_With_Uri_Error_Test_001::End");
1254 }
1255
1256 /**
1257 * @tc.name: SlientAccess_Creator_When_TimeOut_Test_001
1258 * @tc.desc: Test DataShareHelper creation with timeout
1259 * @tc.type: FUNC
1260 * @tc.require: NA
1261 * @tc.precon: None
1262 * @tc.step:
1263 * 1. Get SystemAbilityManager instance and remote object for STORAGE_MANAGER_MANAGER_ID
1264 * 2. Try to create DataShareHelper with valid URI but timeout parameter 0
1265 * 3. Check helper instance
1266 * @tc.expect: Helper creation fails due to timeout (helper == nullptr)
1267 */
1268 HWTEST_F(SlientAccessTest, SlientAccess_Creator_When_TimeOut_Test_001, TestSize.Level0)
1269 {
1270 LOG_INFO("SlientAccess_Creator_With_Uri_Error_Test_001::Begin");
1271 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1272 if (saManager == nullptr) {
1273 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
1274 }
1275 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
1276 if (remoteObj == nullptr) {
1277 LOG_ERROR("GetSystemAbility service failed.");
1278 }
1279 std::string uriStr(DATA_SHARE_URI);
1280 auto helper = DataShare::DataShareHelper::Creator(remoteObj, uriStr, uriStr, 0);
1281 EXPECT_EQ(helper, nullptr);
1282 LOG_INFO("SlientAccess_Creator_With_Uri_Error_Test_001::End");
1283 }
1284
1285 /**
1286 * @tc.name: SlientAccess_UserDefineFunc_Test_001
1287 * @tc.desc: Test custom user-defined function in DataShareHelper
1288 * @tc.type: FUNC
1289 * @tc.require: NA
1290 * @tc.precon: None
1291 * @tc.step:
1292 * 1. Create empty MessageParcel objects for data and reply
1293 * 2. Create default MessageOption
1294 * 3. Call UserDefineFunc() on the helper
1295 * 4. Check return value
1296 * @tc.expect: User-defined function returns 0 (success)
1297 */
1298 HWTEST_F(SlientAccessTest, SlientAccess_UserDefineFunc_Test_001, TestSize.Level0)
1299 {
1300 LOG_INFO("SilentAccess_UserDefineFunc_Test_001::Start");
1301 auto helper = g_slientAccessHelper;
1302 MessageParcel data;
1303 MessageParcel reply;
1304 MessageOption option;
1305 auto result = helper->DataShareHelper::UserDefineFunc(data, reply, option);
1306 EXPECT_EQ(result, 0);
1307 LOG_INFO("SilentAccess_UserDefineFunc_Test_001::End");
1308 }
1309
1310 /**
1311 * @tc.name: SlientAccess_Creator_ErrorBundle_Test_001
1312 * @tc.desc: Test DataShareHelper creation with invalid bundle name in URI
1313 * @tc.type: FUNC
1314 * @tc.require: NA
1315 * @tc.precon: None
1316 * @tc.step:
1317 * 1. Create URI with invalid bundle name ("com.acts.error.bundleName")
1318 * 2. Try to create DataShareHelper with this URI
1319 * 3. Check helper instance
1320 * @tc.expect: Helper creation fails (helper == nullptr) due to invalid bundle name
1321 */
1322 HWTEST_F(SlientAccessTest, SlientAccess_Creator_ErrorBundle_Test_001, TestSize.Level0)
1323 {
1324 LOG_INFO("SlientAccess_Creator_ErrorBundle_Test_001::Start");
1325 std::string uriStr1("datashareproxy://com.acts.error.bundleName/test");
1326 // slientUri is error bundle name, slient access can't find the bundle name, return nullptr
1327 auto helperSilent = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID, uriStr1);
1328 EXPECT_EQ(helperSilent, nullptr);
1329 LOG_INFO("SlientAccess_Creator_ErrorBundle_Test_001::End");
1330 }
1331
1332 /**
1333 * @tc.name: SlientAccess_Creator_ErrorBundle_ExtSuccess_Test_001
1334 * @tc.desc: Test DataShareHelper creation with invalid silent URI but valid ext URI
1335 * @tc.type: FUNC
1336 * @tc.require: NA
1337 * @tc.precon: None
1338 * @tc.step:
1339 * 1. Get SystemAbilityManager instance and remote object for STORAGE_MANAGER_MANAGER_ID
1340 * 2. Try to create DataShareHelper with invalid silent URI but valid ext URI
1341 * 3. Check return code and helper instance
1342 * @tc.expect:
1343 * 1. Return code is E_OK
1344 * 2. Helper instance is not null (success due to valid ext URI)
1345 */
1346 HWTEST_F(SlientAccessTest, SlientAccess_Creator_ErrorBundle_ExtSuccess_Test_001, TestSize.Level0)
1347 {
1348 LOG_INFO("SlientAccess_Creator_ErrorBundle_ExtSuccess_Test_001::Start");
1349 std::string uriStr1(SLIENT_ERROR_URI);
1350 std::string uriStr2 (DATA_SHARE_URI);
1351 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1352 if (saManager == nullptr) {
1353 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
1354 }
1355 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
1356 if (remoteObj == nullptr) {
1357 LOG_ERROR("GetSystemAbility service failed.");
1358 }
1359 // slientUri is error bundleName, extUri is effective, slient access can't find the bundleName, but ext success
1360 auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
1361 EXPECT_EQ(ret, DataShare::E_OK);
1362 EXPECT_NE(helper, nullptr);
1363 helper = nullptr;
1364 LOG_INFO("SlientAccess_Creator_ErrorBundle_ExtSuccess_Test_001::End");
1365 }
1366
1367 /**
1368 * @tc.name: SlientAccess_Create_With_Invalid_AppIndex_Test_001
1369 * @tc.desc: Test DataShareHelper creation with invalid appIndex in URI
1370 * @tc.type: FUNC
1371 * @tc.require: NA
1372 * @tc.precon: None
1373 * @tc.step:
1374 * 1. Create URI with invalid appIndex parameter ("appIndex=-1")
1375 * 2. Try to create DataShareHelper using Create() method
1376 * 3. Try to create DataShareHelper using Creator() method
1377 * 4. Try to create DataShareHelper with CreateOptions
1378 * 5. Check return code and helper instances
1379 * @tc.expect:
1380 * 1. Create() returns E_EXT_URI_INVALID with null helper
1381 * 2. Both Creator() methods return null helper
1382 */
1383 HWTEST_F(SlientAccessTest, SlientAccess_Create_With_Invalid_AppIndex_Test_001, TestSize.Level0)
1384 {
1385 LOG_INFO("SlientAccess_Create_With_Invalid_AppIndex_Test_001::Start");
1386 std::string uri("datashareproxy://com.acts.datasharetest/test?Proxy=true&appIndex=-1");
1387 std::string extUri(DATA_SHARE_URI);
1388 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1389 if (saManager == nullptr) {
1390 LOG_ERROR("GetSystemAbilityManager get samgr failed.");
1391 }
1392 auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
1393 if (remoteObj == nullptr) {
1394 LOG_ERROR("GetSystemAbility service failed.");
1395 }
1396 auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uri, "");
1397 EXPECT_EQ(ret, E_EXT_URI_INVALID);
1398 EXPECT_EQ(helper, nullptr);
1399
1400 helper = DataShare::DataShareHelper::Creator(remoteObj, uri);
1401 EXPECT_EQ(helper, nullptr);
1402
1403 CreateOptions options;
1404 options.isProxy_ = true;
1405 helper = DataShare::DataShareHelper::Creator(uri, options);
1406 EXPECT_EQ(helper, nullptr);
1407 LOG_INFO("SlientAccess_Create_With_Invalid_AppIndex_Test_001::End");
1408 }
1409
1410 /**
1411 * @tc.name: SlientAccess_RegisterObserverExtProvider_Test_001
1412 * @tc.desc: Test RegisterObserverExtProvider with invalid URI (covers generalCtl == nullptr branch)
1413 * @tc.type: FUNC
1414 * @tc.require: NA
1415 * @tc.precon: None
1416 * @tc.step:
1417 * 1. Create invalid URI (SLIENT_ERROR_URI)
1418 * 2. Create DataShareObserverTest instance
1419 * 3. Call RegisterObserverExtProvider with invalid URI and observer
1420 * @tc.expect: No crash occurs, method executes without errors
1421 */
1422 HWTEST_F(SlientAccessTest, SlientAccess_RegisterObserverExtProvider_Test_001, TestSize.Level0)
1423 {
1424 LOG_INFO("SlientAccess_RegisterObserverExtProvider_Test_001::Begin");
1425 auto helper = g_slientAccessHelper;
1426 Uri uri(SLIENT_ERROR_URI);
1427 std::shared_ptr<DataShareObserver> dataObserver = std::make_shared<DataShareObserverTest>();
1428 ASSERT_NE(helper, nullptr);
1429 ASSERT_NE(dataObserver, nullptr);
1430
1431 helper->RegisterObserverExtProvider(uri, dataObserver, false);
1432
1433 LOG_INFO("SlientAccess_RegisterObserverExtProvider_Test_001::End");
1434 }
1435
1436 /**
1437 * @tc.name: SlientAccess_UnregisterObserverExtProvider_Test_001
1438 * @tc.desc: Test UnregisterObserverExtProvider with invalid URI (covers generalCtl == nullptr branch)
1439 * @tc.type: FUNC
1440 * @tc.require: NA
1441 * @tc.precon: None
1442 * @tc.step:
1443 * 1. Create invalid URI (SLIENT_ERROR_URI)
1444 * 2. Create DataShareObserverTest instance
1445 * 3. Call UnregisterObserverExtProvider with invalid URI and observer
1446 * 4. Create dummy ChangeInfo object
1447 * @tc.expect: No crash occurs, method executes without errors
1448 */
1449 HWTEST_F(SlientAccessTest, SlientAccess_UnregisterObserverExtProvider_Test_001, TestSize.Level0)
1450 {
1451 LOG_INFO("SlientAccess_UnregisterObserverExtProvider_Test_001::Begin");
1452 auto helper = g_slientAccessHelper;
1453 Uri uri(SLIENT_ERROR_URI);
1454 std::shared_ptr<DataShareObserver> dataObserver = std::make_shared<DataShareObserverTest>();
1455 ASSERT_NE(helper, nullptr);
1456 ASSERT_NE(dataObserver, nullptr);
1457
1458 helper->UnregisterObserverExtProvider(uri, dataObserver);
1459
1460 ChangeInfo changeInfo = { DataShareObserver::ChangeType::INSERT, { uri } };
1461 LOG_INFO("SlientAccess_UnregisterObserverExtProvider_Test_001::End");
1462 }
1463
1464 /**
1465 * @tc.name: SlientAccess_NotifyChangeExtProvider_Test_001
1466 * @tc.desc: Test NotifyChangeExtProvider with invalid URI (covers generalCtl == nullptr branch)
1467 * @tc.type: FUNC
1468 * @tc.require: NA
1469 * @tc.precon: None
1470 * @tc.step:
1471 * 1. Create invalid URI (SLIENT_ERROR_URI)
1472 * 2. Create DataShareObserverTest instance
1473 * 3. Register observer with invalid URI
1474 * 4. Create ChangeInfo object for INSERT operation
1475 * 5. Call NotifyChangeExtProvider with ChangeInfo
1476 * @tc.expect: No crash occurs, notification process executes without errors
1477 */
1478 HWTEST_F(SlientAccessTest, SlientAccess_NotifyChangeExtProvider_Test_001, TestSize.Level0)
1479 {
1480 LOG_INFO("SlientAccess_NotifyChangeExtProvider_Test_001::Begin");
1481 auto helper = g_slientAccessHelper;
1482 Uri uri(SLIENT_ERROR_URI);
1483 std::shared_ptr<DataShareObserver> dataObserver = std::make_shared<DataShareObserverTest>();
1484 ASSERT_NE(helper, nullptr);
1485 ASSERT_NE(dataObserver, nullptr);
1486
1487 helper->RegisterObserverExtProvider(uri, dataObserver, true);
1488
1489 ChangeInfo changeInfo = { DataShareObserver::ChangeType::INSERT, { uri } };
1490 helper->NotifyChangeExtProvider(changeInfo);
1491
1492 LOG_INFO("SlientAccess_NotifyChangeExtProvider_Test_001::End");
1493 }
1494 } // namespace DataShare
1495 } // namespace OHOS