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
16 #include <cstdint>
17 #include <gtest/gtest.h>
18
19 #include "access_token.h"
20 #include "access_token_db_operator.h"
21 #include "access_token_db.h"
22 #include "accesstoken_kit.h"
23 #include "access_token_error.h"
24 #define private public
25 #include "accesstoken_info_manager.h"
26 #include "accesstoken_manager_service.h"
27 #include "form_manager_access_client.h"
28 #include "permission_manager.h"
29 #undef private
30 #include "accesstoken_callback_stubs.h"
31 #include "callback_death_recipients.h"
32 #include "parameters.h"
33 #include "permission_data_brief.h"
34 #include "token_field_const.h"
35 #include "token_setproc.h"
36
37 using namespace OHOS;
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace Security {
42 namespace AccessToken {
43 namespace {
44 static const char* ENTERPRISE_NORMAL_CHECK = "accesstoken.enterprise_normal_check";
45 static const std::string FORM_VISIBLE_NAME = "#1";
46 static constexpr int USER_ID = 100;
47 static constexpr int INST_INDEX = 0;
48 static constexpr int32_t RANDOM_TOKENID = 123;
49 static constexpr int INVALID_IPC_CODE = 0;
50
51 static PermissionStatus g_permState = {
52 .permissionName = "ohos.permission.CAMERA",
53 .grantStatus = PermissionState::PERMISSION_DENIED,
54 .grantFlag = PermissionFlag::PERMISSION_DEFAULT_FLAG
55 };
56
57 static HapInfoParams g_info = {
58 .userID = USER_ID,
59 .bundleName = "accesstoken_test",
60 .instIndex = INST_INDEX,
61 .appIDDesc = "testtesttesttest"
62 };
63
64 static HapPolicy g_policy = {
65 .apl = APL_NORMAL,
66 .domain = "test.domain",
67 .permStateList = {g_permState}
68 };
69 }
70 class PermissionManagerCoverageTest : public testing::Test {
71 public:
72 static void SetUpTestCase();
73 static void TearDownTestCase();
74 void SetUp();
75 void TearDown();
76 };
77
SetUpTestCase()78 void PermissionManagerCoverageTest::SetUpTestCase()
79 {
80 uint32_t hapSize = 0;
81 uint32_t nativeSize = 0;
82 uint32_t pefDefSize = 0;
83 uint32_t dlpSize = 0;
84 std::map<int32_t, TokenIdInfo> tokenIdAplMap;
85 AccessTokenInfoManager::GetInstance().Init(hapSize, nativeSize, pefDefSize, dlpSize, tokenIdAplMap);
86 }
87
TearDownTestCase()88 void PermissionManagerCoverageTest::TearDownTestCase() {}
89
SetUp()90 void PermissionManagerCoverageTest::SetUp() {}
91
TearDown()92 void PermissionManagerCoverageTest::TearDown() {}
93
94 /*
95 * @tc.name: RegisterAddObserverTest001
96 * @tc.desc: regist form observer
97 * @tc.type: FUNC
98 * @tc.require: issueI5RWXF
99 */
100 HWTEST_F(PermissionManagerCoverageTest, RegisterAddObserverTest001, TestSize.Level4)
101 {
102 AccessTokenID selfTokenId = GetSelfTokenID();
103 AccessTokenID nativeToken = AccessTokenInfoManager::GetInstance().GetNativeTokenId("privacy_service");
104 EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(nativeToken));
105 sptr<FormStateObserverStub> formStateObserver = new (std::nothrow) FormStateObserverStub();
106 EXPECT_NE(formStateObserver, nullptr);
107 EXPECT_EQ(RET_SUCCESS,
108 FormManagerAccessClient::GetInstance().RegisterAddObserver(FORM_VISIBLE_NAME, formStateObserver));
109 EXPECT_EQ(RET_FAILED,
110 FormManagerAccessClient::GetInstance().RegisterAddObserver(FORM_VISIBLE_NAME, nullptr));
111
112 EXPECT_EQ(RET_FAILED,
113 FormManagerAccessClient::GetInstance().RegisterRemoveObserver(FORM_VISIBLE_NAME, nullptr));
114 EXPECT_EQ(RET_SUCCESS,
115 FormManagerAccessClient::GetInstance().RegisterRemoveObserver(FORM_VISIBLE_NAME, formStateObserver));
116 EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(selfTokenId));
117 }
118
119 /*
120 * @tc.name: FormMgrDiedHandle001
121 * @tc.desc: test form manager remote die
122 * @tc.type: FUNC
123 * @tc.require: issueI5RWXF
124 */
125 HWTEST_F(PermissionManagerCoverageTest, FormMgrDiedHandle001, TestSize.Level4)
126 {
127 FormManagerAccessClient::GetInstance().OnRemoteDiedHandle();
128 ASSERT_EQ(nullptr, FormManagerAccessClient::GetInstance().proxy_);
129 ASSERT_EQ(nullptr, FormManagerAccessClient::GetInstance().serviceDeathObserver_);
130 }
131
132 class PermissionRecordManagerCoverTestCb1 : public FormStateObserverStub {
133 public:
PermissionRecordManagerCoverTestCb1()134 PermissionRecordManagerCoverTestCb1()
135 {}
136
~PermissionRecordManagerCoverTestCb1()137 ~PermissionRecordManagerCoverTestCb1()
138 {}
139
NotifyWhetherFormsVisible(const FormVisibilityType visibleType,const std::string & bundleName,std::vector<FormInstance> & formInstances)140 virtual int32_t NotifyWhetherFormsVisible(const FormVisibilityType visibleType,
141 const std::string &bundleName, std::vector<FormInstance> &formInstances) override
142 {
143 return 0;
144 }
145 };
146
147 /**
148 * @tc.name: OnRemoteRequest001
149 * @tc.desc: FormStateObserverStub::OnRemoteRequest function test
150 * @tc.type: FUNC
151 * @tc.require:
152 */
153 HWTEST_F(PermissionManagerCoverageTest, OnRemoteRequest001, TestSize.Level4)
154 {
155 PermissionRecordManagerCoverTestCb1 callback;
156
157 OHOS::MessageParcel reply;
158 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
159
160 OHOS::MessageParcel data1;
161 ASSERT_EQ(true, data1.WriteInterfaceToken(IJsFormStateObserver::GetDescriptor()));
162 EXPECT_EQ(RET_SUCCESS, callback.OnRemoteRequest(static_cast<uint32_t>(
163 IJsFormStateObserver::Message::FORM_STATE_OBSERVER_NOTIFY_WHETHER_FORMS_VISIBLE), data1, reply, option));
164
165 OHOS::MessageParcel data2;
166 ASSERT_EQ(true, data2.WriteInterfaceToken(IJsFormStateObserver::GetDescriptor()));
167 EXPECT_NE(RET_SUCCESS, callback.OnRemoteRequest(static_cast<uint32_t>(INVALID_IPC_CODE), data2, reply, option));
168
169 MessageParcel data3;
170 data3.WriteInterfaceToken(IJsFormStateObserver::GetDescriptor());
171 data3.WriteInt32(0);
172 ASSERT_EQ(true, data3.WriteString(FORM_VISIBLE_NAME));
173 std::vector<FormInstance> formInstances;
174 FormInstance formInstance;
175 formInstances.emplace_back(formInstance);
176 ASSERT_EQ(true, data3.WriteInt32(formInstances.size()));
177 for (auto &parcelable: formInstances) {
178 ASSERT_EQ(true, data3.WriteParcelable(&parcelable));
179 }
180 EXPECT_EQ(RET_SUCCESS, callback.OnRemoteRequest(static_cast<uint32_t>(
181 IJsFormStateObserver::Message::FORM_STATE_OBSERVER_NOTIFY_WHETHER_FORMS_VISIBLE), data3, reply, option));
182
183 uint32_t code = -1;
184 EXPECT_NE(RET_SUCCESS, callback.OnRemoteRequest(code, data3, reply, option));
185 }
186
187 /**
188 * @tc.name: UpdateCapStateToDatabase001
189 * @tc.desc: Test AccessTokenInfoManager::UpdateCapStateToDatabase
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(PermissionManagerCoverageTest, UpdateCapStateToDatabase001, TestSize.Level4)
194 {
195 AccessTokenIDEx tokenIdEx = {0};
196 std::vector<GenericValues> undefValues;
197 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_info, g_policy, tokenIdEx,
198 undefValues));
199
200 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
201 ASSERT_NE(INVALID_TOKENID, tokenId);
202 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().UpdateCapStateToDatabase(tokenId, false));
203
204 AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId);
205 }
206
207 /**
208 * @tc.name: RestorePermissionPolicy001
209 * @tc.desc: PermissionPolicySet::RestorePermissionPolicy function test
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(PermissionManagerCoverageTest, RestorePermissionPolicy001, TestSize.Level4)
214 {
215 GenericValues value1;
216 value1.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
217 value1.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
218 value1.Put(TokenFiledConst::FIELD_GRANT_STATE, static_cast<PermissionState>(3));
219 value1.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
220
221 AccessTokenID tokenId = RANDOM_TOKENID;
222 std::vector<GenericValues> permStateRes1;
223 permStateRes1.emplace_back(value1);
224 std::vector<GenericValues> extendedPermRes1;
225 PermissionDataBrief::GetInstance().RestorePermissionBriefData(
226 tokenId, permStateRes1, extendedPermRes1); // ret != RET_SUCCESS
227 std::vector<BriefPermData> briefPermDataList;
228 ASSERT_EQ(RET_SUCCESS, PermissionDataBrief::GetInstance().GetBriefPermDataByTokenId(tokenId, briefPermDataList));
229
230 GenericValues value2;
231 value2.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
232 value2.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
233 value2.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_DENIED);
234 value2.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
235 GenericValues value3;
236 value3.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
237 value3.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.MICROPHONE");
238 value3.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_DENIED);
239 value3.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
240
241 std::vector<GenericValues> permStateRes2;
242 permStateRes2.emplace_back(value2);
243 permStateRes2.emplace_back(value3);
244 briefPermDataList.clear();
245 PermissionDataBrief::GetInstance().RestorePermissionBriefData(tokenId,
246 permStateRes2, extendedPermRes1); // state.permissionName == iter->permissionName
247 ASSERT_EQ(RET_SUCCESS, PermissionDataBrief::GetInstance().GetBriefPermDataByTokenId(tokenId, briefPermDataList));
248 ASSERT_EQ(static_cast<uint32_t>(2), briefPermDataList.size());
249 }
250
251 /**
252 * @tc.name: AddBriefPermData001
253 * @tc.desc: PermissionDataBrief::AddBriefPermData function test
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(PermissionManagerCoverageTest, AddBriefPermData001, TestSize.Level4)
258 {
259 PermissionDataBrief::GetInstance().DeleteBriefPermDataByTokenId(RANDOM_TOKENID);
260 std::string permissionName = "ohos.permission.INVALID";
261 PermissionState grantStatus = PermissionState::PERMISSION_DENIED;
262 PermissionFlag grantFlag = PermissionFlag::PERMISSION_DEFAULT_FLAG;
263 std::string value = "test";
264 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, PermissionDataBrief::GetInstance().AddBriefPermData(
265 RANDOM_TOKENID, permissionName, grantStatus, grantFlag, value));
266
267 permissionName = "ohos.permission.READ_MEDIA";
268 ASSERT_EQ(AccessTokenError::ERR_TOKEN_INVALID, PermissionDataBrief::GetInstance().AddBriefPermData(
269 RANDOM_TOKENID, permissionName, grantStatus, grantFlag, value));
270 }
271
272 /**
273 * @tc.name: GetMasterAppUndValues001
274 * @tc.desc: PermissionManager::GetMasterAppUndValues function test
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(PermissionManagerCoverageTest, GetMasterAppUndValues001, TestSize.Level4)
279 {
280 AccessTokenID tokenID = RANDOM_TOKENID;
281 std::vector<GenericValues> undefValues;
282 PermissionManager::GetInstance().GetMasterAppUndValues(tokenID, undefValues);
283 ASSERT_EQ(true, undefValues.empty());
284 }
285
286 /**
287 * @tc.name: InitPermissionList001
288 * @tc.desc: PermissionManager::InitPermissionList function test
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(PermissionManagerCoverageTest, InitPermissionList001, TestSize.Level4)
293 {
294 PermissionStatus status1; // user grant permission ohos.permission.READ_MEDIA with pre-authorization
295 status1.permissionName = "ohos.permission.READ_MEDIA";
296 status1.grantStatus = static_cast<int32_t>(PermissionState::PERMISSION_DENIED);
297 status1.grantFlag = static_cast<uint32_t>(PermissionFlag::PERMISSION_DEFAULT_FLAG);
298 PermissionStatus status2; // user grant permission ohos.permission.WRITE_MEDIA without pre-authorization
299 status2.permissionName = "ohos.permission.WRITE_MEDIA";
300 status2.grantStatus = static_cast<int32_t>(PermissionState::PERMISSION_DENIED);
301 status2.grantFlag = static_cast<uint32_t>(PermissionFlag::PERMISSION_DEFAULT_FLAG);
302 PreAuthorizationInfo info;
303 info.permissionName = "ohos.permission.READ_MEDIA";
304
305 HapPolicy policy;
306 policy.apl = ATokenAplEnum::APL_SYSTEM_BASIC;
307 policy.permStateList.emplace_back(status1);
308 policy.permStateList.emplace_back(status2);
309 policy.preAuthorizationInfo.emplace_back(info);
310
311 HapInfoParams param;
312 param.appDistributionType = "os_integration";
313
314 HapInitInfo initInfo;
315 initInfo.policy = policy;
316 initInfo.installInfo = param;
317 std::vector<PermissionStatus> initializedList;
318 HapInfoCheckResult result;
319 std::vector<GenericValues> undefValues;
320 ASSERT_EQ(true, PermissionManager::GetInstance().InitPermissionList(
321 initInfo, initializedList, result, undefValues));
322 ASSERT_EQ(2, initializedList.size());
323 for (const auto& status : initializedList) {
324 if (status.permissionName == "ohos.permission.READ_MEDIA") {
325 ASSERT_EQ(static_cast<uint32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED), status.grantFlag);
326 }
327 }
328 ASSERT_EQ(true, undefValues.empty());
329 }
330
331 /**
332 * @tc.name: UpdateUndefinedInfo001
333 * @tc.desc: AccessTokenManagerService::UpdateUndefinedInfo function test
334 * @tc.type: FUNC
335 * @tc.require:
336 */
337 HWTEST_F(PermissionManagerCoverageTest, UpdateUndefinedInfo001, TestSize.Level4)
338 {
339 AccessTokenIDEx tokenIdEx = {0};
340 std::vector<GenericValues> undefValues;
341 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_info, g_policy, tokenIdEx,
342 undefValues));
343 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
344 ASSERT_NE(INVALID_TOKENID, tokenId);
345
346 GenericValues value1;
347 value1.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId)); // permissionName invalid
348 value1.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.INVALID");
349 value1.Put(TokenFiledConst::FIELD_ACL, 0);
350 GenericValues value2;
351 value2.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID); // tokenID invalid
352 value2.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.READ_MEDIA");
353 value2.Put(TokenFiledConst::FIELD_ACL, 0);
354 std::vector<GenericValues> validValueList;
355 validValueList.emplace_back(value1);
356 validValueList.emplace_back(value2);
357
358 PermissionDataBrief::GetInstance().DeleteBriefPermDataByTokenId(RANDOM_TOKENID);
359 std::shared_ptr<AccessTokenManagerService> atManagerService_ =
360 DelayedSingleton<AccessTokenManagerService>::GetInstance();
361 ASSERT_NE(nullptr, atManagerService_);
362
363 std::vector<GenericValues> stateValues;
364 std::vector<GenericValues> extendValues;
365 atManagerService_->UpdateUndefinedInfoCache(validValueList, stateValues, extendValues);
366 ASSERT_EQ(true, stateValues.empty());
367 ASSERT_EQ(true, extendValues.empty());
368 ASSERT_EQ(RET_SUCCESS, atManagerService_->DeleteToken(tokenId));
369 atManagerService_ = nullptr;
370 }
371
BackupAndDelOriData(AtmDataType type,std::vector<GenericValues> & oriData)372 void BackupAndDelOriData(AtmDataType type, std::vector<GenericValues>& oriData)
373 {
374 GenericValues conditionValue;
375 // store origin data for backup
376 ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance()->Find(type, conditionValue, oriData));
377
378 DelInfo delInfo;
379 delInfo.delType = type;
380
381 std::vector<DelInfo> delInfoVec;
382 delInfoVec.emplace_back(delInfo);
383 std::vector<AddInfo> addInfoVec;
384 // delete origin data from db
385 ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec));
386 }
387
DelTestDataAndRestoreOri(AtmDataType type,const std::vector<GenericValues> & oriData)388 void DelTestDataAndRestoreOri(AtmDataType type, const std::vector<GenericValues>& oriData)
389 {
390 DelInfo delInfo;
391 delInfo.delType = type;
392
393 AddInfo addInfo;
394 addInfo.addType = type;
395 addInfo.addValues = oriData;
396
397 std::vector<DelInfo> delInfoVec;
398 delInfoVec.emplace_back(delInfo);
399 std::vector<AddInfo> addInfoVec;
400 addInfoVec.emplace_back(addInfo);
401 // delete test data and restore origin data from backup
402 ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec));
403 }
404
405 /**
406 * @tc.name: HandleHapUndefinedInfo001
407 * @tc.desc: AccessTokenManagerService::HandleHapUndefinedInfo function test
408 * @tc.type: FUNC
409 * @tc.require:
410 */
411 HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo001, TestSize.Level4)
412 {
413 AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
414 std::vector<GenericValues> oriData;
415 BackupAndDelOriData(type, oriData);
416
417 std::shared_ptr<AccessTokenManagerService> atManagerService_ =
418 DelayedSingleton<AccessTokenManagerService>::GetInstance();
419 EXPECT_NE(nullptr, atManagerService_);
420
421 std::map<int32_t, TokenIdInfo> tokenIdAplMap;
422 std::vector<DelInfo> delInfoVec;
423 std::vector<AddInfo> addInfoVec;
424 atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec, addInfoVec);
425
426 DelTestDataAndRestoreOri(type, oriData);
427 atManagerService_ = nullptr;
428 }
429
430 /**
431 * @tc.name: HandleHapUndefinedInfo002
432 * @tc.desc: AccessTokenManagerService::HandleHapUndefinedInfo function test
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo002, TestSize.Level4)
437 {
438 AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
439 std::vector<GenericValues> oriData;
440 BackupAndDelOriData(type, oriData);
441
442 GenericValues value;
443 value.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
444 value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.SET_ENTERPRISE_INFO"); // mdm permission
445 value.Put(TokenFiledConst::FIELD_ACL, 0);
446 value.Put(TokenFiledConst::FIELD_APP_DISTRIBUTION_TYPE, "os_integration");
447 AddInfo addInfo;
448 addInfo.addType = type;
449 addInfo.addValues.emplace_back(value);
450
451 std::vector<DelInfo> delInfoVec;
452 std::vector<AddInfo> addInfoVec;
453 addInfoVec.emplace_back(addInfo);
454 // add test data
455 EXPECT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec));
456
457 std::shared_ptr<AccessTokenManagerService> atManagerService_ =
458 DelayedSingleton<AccessTokenManagerService>::GetInstance();
459 EXPECT_NE(nullptr, atManagerService_);
460
461 std::map<int32_t, TokenIdInfo> tokenIdAplMap;
462 std::vector<DelInfo> delInfoVec2;
463 std::vector<AddInfo> addInfoVec2;
464 atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
465
466 DelTestDataAndRestoreOri(type, oriData);
467 atManagerService_ = nullptr;
468 }
469
470 /**
471 * @tc.name: HandleHapUndefinedInfo003
472 * @tc.desc: AccessTokenManagerService::HandleHapUndefinedInfo function test
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo003, TestSize.Level4)
477 {
478 AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
479 std::vector<GenericValues> oriData;
480 BackupAndDelOriData(type, oriData);
481
482 GenericValues value;
483 value.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
484 // enterprise_normal permission
485 value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.FILE_GUARD_MANAGER");
486 value.Put(TokenFiledConst::FIELD_ACL, 0);
487 value.Put(TokenFiledConst::FIELD_APP_DISTRIBUTION_TYPE, "os_integration");
488 AddInfo addInfo;
489 addInfo.addType = type;
490 addInfo.addValues.emplace_back(value);
491
492 std::vector<DelInfo> delInfoVec;
493 std::vector<AddInfo> addInfoVec;
494 addInfoVec.emplace_back(addInfo);
495 // add test data
496 EXPECT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec));
497
498 std::shared_ptr<AccessTokenManagerService> atManagerService_ =
499 DelayedSingleton<AccessTokenManagerService>::GetInstance();
500 EXPECT_NE(nullptr, atManagerService_);
501
502 std::map<int32_t, TokenIdInfo> tokenIdAplMap;
503 std::vector<DelInfo> delInfoVec2;
504 std::vector<AddInfo> addInfoVec2;
505 atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
506
507 DelTestDataAndRestoreOri(type, oriData);
508 atManagerService_ = nullptr;
509 }
510
511 /**
512 * @tc.name: HandlePermDefUpdate001
513 * @tc.desc: AccessTokenManagerService::HandlePermDefUpdate function test
514 * @tc.type: FUNC
515 * @tc.require:
516 */
517 HWTEST_F(PermissionManagerCoverageTest, HandlePermDefUpdate001, TestSize.Level4)
518 {
519 AtmDataType type = AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG;
520 std::vector<GenericValues> oriData;
521 BackupAndDelOriData(type, oriData);
522
523 std::shared_ptr<AccessTokenManagerService> atManagerService_ =
524 DelayedSingleton<AccessTokenManagerService>::GetInstance();
525 EXPECT_NE(nullptr, atManagerService_);
526
527 std::map<int32_t, TokenIdInfo> tokenIdAplMap;
528 atManagerService_->HandlePermDefUpdate(tokenIdAplMap); // dbPermDefVersion is empty
529
530 DelTestDataAndRestoreOri(type, oriData);
531 atManagerService_ = nullptr;
532 }
533
534 /**
535 * @tc.name: HandlePermDefUpdate002
536 * @tc.desc: AccessTokenManagerService::HandlePermDefUpdate function test
537 * @tc.type: FUNC
538 * @tc.require:
539 */
540 HWTEST_F(PermissionManagerCoverageTest, HandlePermDefUpdate002, TestSize.Level4)
541 {
542 AtmDataType type = AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG;
543 std::vector<GenericValues> oriData;
544 BackupAndDelOriData(type, oriData);
545
546 GenericValues addValue;
547 addValue.Put(TokenFiledConst::FIELD_NAME, PERM_DEF_VERSION);
548 addValue.Put(TokenFiledConst::FIELD_VALUE, "sfdsfdsfsf"); // random input
549 AddInfo addInfo;
550 addInfo.addType = type;
551 addInfo.addValues.emplace_back(addValue);
552
553 std::vector<DelInfo> delInfoVec;
554 std::vector<AddInfo> addInfoVec;
555 addInfoVec.emplace_back(addInfo);
556 // update permission define version in db to test data
557 EXPECT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec));
558
559 std::shared_ptr<AccessTokenManagerService> atManagerService_ =
560 DelayedSingleton<AccessTokenManagerService>::GetInstance();
561 EXPECT_NE(nullptr, atManagerService_);
562
563 std::map<int32_t, TokenIdInfo> tokenIdAplMap;
564 atManagerService_->HandlePermDefUpdate(tokenIdAplMap); // dbPermDefVersion is not empty
565
566 DelTestDataAndRestoreOri(type, oriData);
567 atManagerService_ = nullptr;
568 }
569
570 /**
571 * @tc.name: IsPermAvailableRangeSatisfied001
572 * @tc.desc: PermissionManager::IsPermAvailableRangeSatisfied function test
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(PermissionManagerCoverageTest, IsPermAvailableRangeSatisfied001, TestSize.Level4)
577 {
578 PermissionBriefDef briefDef;
579 briefDef.availableType = ATokenAvailableTypeEnum::ENTERPRISE_NORMAL;
580 char permissionName[] = "ohos.permission.FILE_GUARD_MANAGER";
581 briefDef.permissionName = permissionName;
582 std::string appDistributionType = "os_integration";
583 bool isSystemApp = false;
584 PermissionRulesEnum rule;
585 HapInitInfo initInfo;
586 system::SetBoolParameter(ENTERPRISE_NORMAL_CHECK, true);
587 ASSERT_FALSE(PermissionManager::GetInstance().IsPermAvailableRangeSatisfied(
588 briefDef, appDistributionType, isSystemApp, rule, initInfo));
589 system::SetBoolParameter(ENTERPRISE_NORMAL_CHECK, false);
590 ASSERT_TRUE(PermissionManager::GetInstance().IsPermAvailableRangeSatisfied(
591 briefDef, appDistributionType, isSystemApp, rule, initInfo));
592 }
593 } // namespace AccessToken
594 } // namespace Security
595 } // namespace OHOS
596