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
16 #include "accesstoken_info_manager_test.h"
17
18 #include <gmock/gmock.h>
19
20 #include "accesstoken_id_manager.h"
21 #include "access_token_error.h"
22 #define private public
23 #include "accesstoken_callback_stubs.h"
24 #include "accesstoken_info_manager.h"
25 #include "accesstoken_remote_token_manager.h"
26 #include "libraryloader.h"
27 #include "token_field_const.h"
28 #ifdef TOKEN_SYNC_ENABLE
29 #include "token_sync_kit_loader.h"
30 #endif
31 #include "permission_definition_cache.h"
32 #include "permission_manager.h"
33 #include "token_modify_notifier.h"
34 #undef private
35 #include "permission_validator.h"
36 #include "string_ex.h"
37 #include "token_setproc.h"
38
39 using namespace testing::ext;
40 using namespace OHOS;
41
42 namespace OHOS {
43 namespace Security {
44 namespace AccessToken {
45 namespace {
46 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
47 LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenInfoManagerTest"
48 };
49 static std::map<std::string, PermissionDefData> g_permissionDefinitionMap;
50 static bool g_hasHapPermissionDefinition;
51 static constexpr int32_t DEFAULT_API_VERSION = 8;
52 static constexpr int USER_ID = 100;
53 static constexpr int INST_INDEX = 0;
54 static PermissionDef g_infoManagerTestPermDef1 = {
55 .permissionName = "open the door",
56 .bundleName = "accesstoken_test",
57 .grantMode = 1,
58 .availableLevel = APL_NORMAL,
59 .provisionEnable = false,
60 .distributedSceneEnable = false,
61 .label = "label",
62 .labelId = 1,
63 .description = "open the door",
64 .descriptionId = 1
65 };
66
67 static PermissionDef g_infoManagerTestPermDef2 = {
68 .permissionName = "break the door",
69 .bundleName = "accesstoken_test",
70 .grantMode = 1,
71 .availableLevel = APL_NORMAL,
72 .provisionEnable = false,
73 .distributedSceneEnable = false,
74 .label = "label",
75 .labelId = 1,
76 .description = "break the door",
77 .descriptionId = 1
78 };
79
80 static PermissionStateFull g_infoManagerTestState1 = {
81 .permissionName = "open the door",
82 .isGeneral = true,
83 .resDeviceID = {"local"},
84 .grantStatus = {1},
85 .grantFlags = {1}
86 };
87
88 static PermissionStateFull g_infoManagerTestState2 = {
89 .permissionName = "break the door",
90 .isGeneral = false,
91 .resDeviceID = {"device 1", "device 2"},
92 .grantStatus = {1, 3},
93 .grantFlags = {1, 2}
94 };
95
96 static HapInfoParams g_infoManagerTestInfoParms = {
97 .userID = 1,
98 .bundleName = "accesstoken_test",
99 .instIndex = 0,
100 .appIDDesc = "testtesttesttest"
101 };
102
103 static HapPolicyParams g_infoManagerTestPolicyPrams1 = {
104 .apl = APL_NORMAL,
105 .domain = "test.domain",
106 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
107 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
108 };
109
110 static PermissionStateFull g_permState = {
111 .permissionName = "ohos.permission.CAMERA",
112 .isGeneral = false,
113 .resDeviceID = {"dev-001", "dev-001"},
114 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
115 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
116 };
117
118 #ifdef TOKEN_SYNC_ENABLE
119 static const int32_t FAKE_SYNC_RET = 0xabcdef;
120 class TokenSyncCallbackMock : public TokenSyncCallbackStub {
121 public:
122 TokenSyncCallbackMock() = default;
123 virtual ~TokenSyncCallbackMock() = default;
124
125 MOCK_METHOD(int32_t, GetRemoteHapTokenInfo, (const std::string&, AccessTokenID), (override));
126 MOCK_METHOD(int32_t, DeleteRemoteHapTokenInfo, (AccessTokenID), (override));
127 MOCK_METHOD(int32_t, UpdateRemoteHapTokenInfo, (const HapTokenInfoForSync&), (override));
128 };
129 #endif
130 }
131
SetUpTestCase()132 void AccessTokenInfoManagerTest::SetUpTestCase()
133 {
134 AccessTokenInfoManager::GetInstance().Init();
135 }
136
TearDownTestCase()137 void AccessTokenInfoManagerTest::TearDownTestCase()
138 {
139 sleep(3); // delay 3 minutes
140 }
141
SetUp()142 void AccessTokenInfoManagerTest::SetUp()
143 {
144 atManagerService_ = DelayedSingleton<AccessTokenManagerService>::GetInstance();
145 EXPECT_NE(nullptr, atManagerService_);
146 PermissionDef infoManagerPermDefA = {
147 .permissionName = "ohos.permission.CAMERA",
148 .bundleName = "accesstoken_test",
149 .grantMode = USER_GRANT,
150 .availableLevel = APL_NORMAL,
151 .provisionEnable = false,
152 .distributedSceneEnable = false,
153 };
154 PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDefA, 1);
155 PermissionDef infoManagerPermDefB = {
156 .permissionName = "ohos.permission.LOCATION",
157 .bundleName = "accesstoken_test",
158 .grantMode = USER_GRANT,
159 .availableLevel = APL_NORMAL,
160 .provisionEnable = false,
161 .distributedSceneEnable = false,
162 };
163 PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDefB, 1);
164 g_permissionDefinitionMap = PermissionDefinitionCache::GetInstance().permissionDefinitionMap_;
165 g_hasHapPermissionDefinition = PermissionDefinitionCache::GetInstance().hasHapPermissionDefinition_;
166 }
167
TearDown()168 void AccessTokenInfoManagerTest::TearDown()
169 {
170 PermissionDefinitionCache::GetInstance().permissionDefinitionMap_ = g_permissionDefinitionMap; // recovery
171 PermissionDefinitionCache::GetInstance().hasHapPermissionDefinition_ = g_hasHapPermissionDefinition;
172 atManagerService_ = nullptr;
173 }
174
175 /**
176 * @tc.name: HapTokenInfoInner001
177 * @tc.desc: HapTokenInfoInner::HapTokenInfoInner.
178 * @tc.type: FUNC
179 * @tc.require:
180 */
HWTEST_F(AccessTokenInfoManagerTest, HapTokenInfoInner001, TestSize.Level1)181 HWTEST_F(AccessTokenInfoManagerTest, HapTokenInfoInner001, TestSize.Level1)
182 {
183 AccessTokenID id = 0x20240112;
184 HapTokenInfo info = {
185 .apl = APL_NORMAL,
186 .ver = 1,
187 .userID = 1,
188 .bundleName = "com.ohos.access_token",
189 .instIndex = 1,
190 .appID = "testtesttesttest",
191 .deviceID = "deviceId",
192 .tokenID = id,
193 .tokenAttr = 0
194 };
195 std::vector<PermissionStateFull> permStateList;
196 std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>(id, info, permStateList);
197 ASSERT_EQ(hap->IsRemote(), false);
198 hap->SetRemote(true);
199 std::vector<GenericValues> valueList;
200 hap->StoreHapInfo(valueList);
201
202 hap->StorePermissionPolicy(valueList);
203 ASSERT_EQ(hap->IsRemote(), true);
204 hap->SetRemote(false);
205 int32_t version = hap->GetApiVersion(5608);
206 ASSERT_EQ(static_cast<int32_t>(608), version);
207 }
208
209 /**
210 * @tc.name: CreateHapTokenInfo001
211 * @tc.desc: Verify the CreateHapTokenInfo add one hap token function.
212 * @tc.type: FUNC
213 * @tc.require:
214 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo001, TestSize.Level1)215 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo001, TestSize.Level1)
216 {
217 AccessTokenIDEx tokenIdEx = {0};
218 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
219 g_infoManagerTestPolicyPrams1, tokenIdEx);
220 ASSERT_EQ(RET_SUCCESS, ret);
221 GTEST_LOG_(INFO) << "add a hap token";
222
223 std::shared_ptr<HapTokenInfoInner> tokenInfo;
224 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
225 ASSERT_NE(nullptr, tokenInfo);
226 std::string infoDes;
227 tokenInfo->ToString(infoDes);
228 GTEST_LOG_(INFO) << "get hap token info:" << infoDes.c_str();
229
230 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
231 ASSERT_EQ(RET_SUCCESS, ret);
232 GTEST_LOG_(INFO) << "remove the token info";
233
234 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
235 ASSERT_EQ(nullptr, tokenInfo);
236 }
237
238 /**
239 * @tc.name: CreateHapTokenInfo002
240 * @tc.desc: Verify the CreateHapTokenInfo add one hap token twice function.
241 * @tc.type: FUNC
242 * @tc.require:
243 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo002, TestSize.Level1)244 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo002, TestSize.Level1)
245 {
246 ACCESSTOKEN_LOG_INFO(LABEL, "AddHapToken001 fill data");
247
248 AccessTokenIDEx tokenIdEx = {0};
249 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
250 g_infoManagerTestPolicyPrams1, tokenIdEx);
251 ASSERT_EQ(RET_SUCCESS, ret);
252 GTEST_LOG_(INFO) << "add a hap token";
253
254 AccessTokenIDEx tokenIdEx1 = {0};
255 ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
256 g_infoManagerTestPolicyPrams1, tokenIdEx1);
257 ASSERT_EQ(RET_SUCCESS, ret);
258 ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, tokenIdEx1.tokenIdExStruct.tokenID);
259 GTEST_LOG_(INFO) << "add same hap token";
260 PermissionDef permDef;
261 ASSERT_EQ(RET_SUCCESS,
262 PermissionManager::GetInstance().GetDefPermission(g_infoManagerTestPermDef1.permissionName, permDef));
263 ASSERT_EQ(permDef.permissionName, g_infoManagerTestPermDef1.permissionName);
264
265 std::shared_ptr<HapTokenInfoInner> tokenInfo;
266 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx1.tokenIdExStruct.tokenID);
267 ASSERT_NE(nullptr, tokenInfo);
268
269 std::string infoDes;
270 tokenInfo->ToString(infoDes);
271 GTEST_LOG_(INFO) << "get hap token info:" << infoDes.c_str();
272
273 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx1.tokenIdExStruct.tokenID);
274 ASSERT_EQ(RET_SUCCESS, ret);
275 GTEST_LOG_(INFO) << "remove the token info";
276 }
277
278 /**
279 * @tc.name: CreateHapTokenInfo003
280 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test userID invalid
281 * @tc.type: FUNC
282 * @tc.require:
283 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo003, TestSize.Level1)284 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo003, TestSize.Level1)
285 {
286 HapInfoParams info = {
287 .userID = -1
288 };
289 HapPolicyParams policy;
290 AccessTokenIDEx tokenIdEx;
291
292 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
293 }
294
295 /**
296 * @tc.name: CreateHapTokenInfo004
297 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test bundleName invalid
298 * @tc.type: FUNC
299 * @tc.require:
300 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo004, TestSize.Level1)301 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo004, TestSize.Level1)
302 {
303 HapInfoParams info = {
304 .userID = USER_ID,
305 .bundleName = ""
306 };
307 HapPolicyParams policy;
308 AccessTokenIDEx tokenIdEx;
309
310 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
311 }
312
313 /**
314 * @tc.name: CreateHapTokenInfo005
315 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test appIDDesc invalid
316 * @tc.type: FUNC
317 * @tc.require:
318 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo005, TestSize.Level1)319 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo005, TestSize.Level1)
320 {
321 HapInfoParams info = {
322 .userID = USER_ID,
323 .bundleName = "ohos.com.testtesttest",
324 .appIDDesc = ""
325 };
326 HapPolicyParams policy;
327 AccessTokenIDEx tokenIdEx;
328
329 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
330 }
331
332 /**
333 * @tc.name: CreateHapTokenInfo006
334 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test domain invalid
335 * @tc.type: FUNC
336 * @tc.require:
337 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo006, TestSize.Level1)338 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo006, TestSize.Level1)
339 {
340 HapInfoParams info = {
341 .userID = USER_ID,
342 .bundleName = "ohos.com.testtesttest",
343 .appIDDesc = "who cares"
344 };
345 HapPolicyParams policy = {
346 .domain = ""
347 };
348 AccessTokenIDEx tokenIdEx;
349
350 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
351 }
352
353 /**
354 * @tc.name: CreateHapTokenInfo007
355 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test dlpType invalid
356 * @tc.type: FUNC
357 * @tc.require:
358 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo007, TestSize.Level1)359 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo007, TestSize.Level1)
360 {
361 HapInfoParams info = {
362 .userID = USER_ID,
363 .bundleName = "ohos.com.testtesttest",
364 .dlpType = -1,
365 .appIDDesc = "who cares"
366 };
367 HapPolicyParams policy = {
368 .domain = "who cares"
369 };
370 AccessTokenIDEx tokenIdEx;
371
372 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
373 }
374
375 /**
376 * @tc.name: CreateHapTokenInfo008
377 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test grant mode invalid
378 * @tc.type: FUNC
379 * @tc.require:
380 */
HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo008, TestSize.Level1)381 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo008, TestSize.Level1)
382 {
383 static PermissionDef permDef = {
384 .permissionName = "ohos.permission.test",
385 .bundleName = "accesstoken_test",
386 .grantMode = -1, // -1:invalid grant mode
387 .availableLevel = APL_NORMAL,
388 .provisionEnable = false,
389 .distributedSceneEnable = false,
390 .label = "label",
391 .labelId = 1,
392 .description = "open the door",
393 .descriptionId = 1
394 };
395 HapInfoParams info = {
396 .userID = USER_ID,
397 .bundleName = "ohos.com.testtesttest",
398 .appIDDesc = ""
399 };
400 HapPolicyParams policy = {
401 .apl = APL_NORMAL,
402 .domain = "test.domain",
403 .permList = {permDef}
404 };
405 AccessTokenIDEx tokenIdEx;
406 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
407 }
408
409 /**
410 * @tc.name: InitHapToken001
411 * @tc.desc: InitHapToken function test with invalid userID
412 * @tc.type: FUNC
413 * @tc.require:
414 */
HWTEST_F(AccessTokenInfoManagerTest, InitHapToken001, TestSize.Level1)415 HWTEST_F(AccessTokenInfoManagerTest, InitHapToken001, TestSize.Level1)
416 {
417 HapInfoParcel hapinfoParcel;
418 hapinfoParcel.hapInfoParameter = {
419 .userID = -1,
420 .bundleName = "accesstoken_test",
421 .instIndex = 0,
422 .dlpType = DLP_COMMON,
423 .appIDDesc = "testtesttesttest",
424 .apiVersion = DEFAULT_API_VERSION,
425 .isSystemApp = false,
426 };
427 HapPolicyParcel hapPolicyParcel;
428 hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
429 hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
430 AccessTokenIDEx tokenIdEx;
431 ASSERT_EQ(ERR_PARAM_INVALID, atManagerService_->InitHapToken(hapinfoParcel, hapPolicyParcel, tokenIdEx));
432 }
433
434 /**
435 * @tc.name: InitHapToken002
436 * @tc.desc: InitHapToken function test with invalid userID
437 * @tc.type: FUNC
438 * @tc.require:
439 */
HWTEST_F(AccessTokenInfoManagerTest, InitHapToken002, TestSize.Level1)440 HWTEST_F(AccessTokenInfoManagerTest, InitHapToken002, TestSize.Level1)
441 {
442 HapInfoParcel hapinfoParcel;
443 hapinfoParcel.hapInfoParameter = {
444 .userID = -1,
445 .bundleName = "accesstoken_test",
446 .instIndex = 0,
447 .dlpType = DLP_READ,
448 .appIDDesc = "testtesttesttest",
449 .apiVersion = DEFAULT_API_VERSION,
450 .isSystemApp = false,
451 };
452 HapPolicyParcel hapPolicyParcel;
453 hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
454 hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
455 AccessTokenIDEx tokenIdEx;
456 ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, atManagerService_->InitHapToken(hapinfoParcel, hapPolicyParcel, tokenIdEx));
457 }
458
459 /**
460 * @tc.name: InitHapToken003
461 * @tc.desc: InitHapToken function test with invalid apl permission
462 * @tc.type: FUNC
463 * @tc.require:
464 */
HWTEST_F(AccessTokenInfoManagerTest, InitHapToken003, TestSize.Level1)465 HWTEST_F(AccessTokenInfoManagerTest, InitHapToken003, TestSize.Level1)
466 {
467 HapInfoParcel info;
468 info.hapInfoParameter = {
469 .userID = 0,
470 .bundleName = "accesstoken_test",
471 .instIndex = 0,
472 .dlpType = DLP_COMMON,
473 .appIDDesc = "testtesttesttest",
474 .apiVersion = DEFAULT_API_VERSION,
475 .isSystemApp = false,
476 };
477 HapPolicyParcel policy;
478 PermissionStateFull permissionStateA = {
479 .permissionName = "ohos.permission.GET_ALL_APP_ACCOUNTS",
480 .isGeneral = true,
481 .resDeviceID = {"local"},
482 .grantStatus = {1},
483 .grantFlags = {1}
484 };
485 PermissionStateFull permissionStateB = {
486 .permissionName = "ohos.permission.PRELOAD_APPLICATION",
487 .isGeneral = true,
488 .resDeviceID = {"local"},
489 .grantStatus = {1},
490 .grantFlags = {1}
491 };
492 PermissionStateFull permissionStateC = {
493 .permissionName = "ohos.permission.test",
494 .isGeneral = true,
495 .resDeviceID = {"local"},
496 .grantStatus = {1},
497 .grantFlags = {1}
498 };
499 policy.hapPolicyParameter = {
500 .apl = APL_NORMAL,
501 .domain = "test",
502 .permList = {},
503 .permStateList = { permissionStateA }
504 };
505 AccessTokenIDEx fullTokenId = {0};
506 ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, atManagerService_->InitHapToken(info, policy, fullTokenId));
507
508 policy.hapPolicyParameter.permStateList = { permissionStateB, permissionStateC };
509 policy.hapPolicyParameter.aclRequestedList = { "ohos.permission.PRELOAD_APPLICATION" };
510 ASSERT_EQ(RET_SUCCESS, atManagerService_->InitHapToken(info, policy, fullTokenId));
511 }
512
513 /**
514 * @tc.name: IsTokenIdExist001
515 * @tc.desc: Verify the IsTokenIdExist exist accesstokenid.
516 * @tc.type: FUNC
517 * @tc.require:
518 */
HWTEST_F(AccessTokenInfoManagerTest, IsTokenIdExist001, TestSize.Level1)519 HWTEST_F(AccessTokenInfoManagerTest, IsTokenIdExist001, TestSize.Level1)
520 {
521 AccessTokenID testId = 1;
522 ASSERT_EQ(AccessTokenInfoManager::GetInstance().IsTokenIdExist(testId), false);
523 }
524
525 /**
526 * @tc.name: GetHapTokenInfo001
527 * @tc.desc: Verify the GetHapTokenInfo abnormal and normal branch.
528 * @tc.type: FUNC
529 * @tc.require:
530 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenInfo001, TestSize.Level1)531 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenInfo001, TestSize.Level1)
532 {
533 AccessTokenIDEx tokenIdEx = {0};
534 int result;
535 HapTokenInfo hapInfo;
536 result = AccessTokenInfoManager::GetInstance().GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapInfo);
537 ASSERT_EQ(result, ERR_TOKENID_NOT_EXIST);
538
539 result = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
540 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
541 ASSERT_EQ(RET_SUCCESS, result);
542 GTEST_LOG_(INFO) << "add a hap token";
543 result = AccessTokenInfoManager::GetInstance().GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapInfo);
544 ASSERT_EQ(result, RET_SUCCESS);
545 result = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
546 ASSERT_EQ(RET_SUCCESS, result);
547 GTEST_LOG_(INFO) << "remove the token info";
548 }
549
550 /**
551 * @tc.name: GetHapPermissionPolicySet001
552 * @tc.desc: Verify the GetHapPermissionPolicySet abnormal and normal branch.
553 * @tc.type: FUNC
554 * @tc.require:
555 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapPermissionPolicySet001, TestSize.Level1)556 HWTEST_F(AccessTokenInfoManagerTest, GetHapPermissionPolicySet001, TestSize.Level1)
557 {
558 AccessTokenIDEx tokenIdEx = {0};
559 std::shared_ptr<PermissionPolicySet> permPolicySet =
560 AccessTokenInfoManager::GetInstance().GetHapPermissionPolicySet(tokenIdEx.tokenIdExStruct.tokenID);
561 ASSERT_EQ(permPolicySet, nullptr);
562
563 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
564 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
565 ASSERT_EQ(RET_SUCCESS, ret);
566 GTEST_LOG_(INFO) << "add a hap token";
567 permPolicySet = AccessTokenInfoManager::GetInstance().GetHapPermissionPolicySet(tokenIdEx.tokenIdExStruct.tokenID);
568 ASSERT_EQ(permPolicySet != nullptr, true);
569 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
570 ASSERT_EQ(RET_SUCCESS, ret);
571 GTEST_LOG_(INFO) << "remove the token info";
572 }
573
574 /**
575 * @tc.name: RemoveHapTokenInfo001
576 * @tc.desc: Verify the RemoveHapTokenInfo abnormal branch tokenID type is not true.
577 * @tc.type: FUNC
578 * @tc.require:
579 */
HWTEST_F(AccessTokenInfoManagerTest, RemoveHapTokenInfo001, TestSize.Level1)580 HWTEST_F(AccessTokenInfoManagerTest, RemoveHapTokenInfo001, TestSize.Level1)
581 {
582 AccessTokenIDEx tokenIdEx = {0};
583 // type != TOKEN_HAP
584 ASSERT_EQ(
585 ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID));
586
587 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
588 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
589 // hapTokenInfoMap_.count(id) == 0
590 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
591
592 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
593 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = nullptr;
594 ASSERT_EQ(ERR_TOKEN_INVALID, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId)); // info == nullptr
595 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
596
597 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
598 info->tokenInfoBasic_.userID = USER_ID;
599 info->tokenInfoBasic_.bundleName = "com.ohos.TEST";
600 info->tokenInfoBasic_.instIndex = INST_INDEX;
601 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
602 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
603 // count(HapUniqueKey) == 0
604 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
605
606 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP)); // removed above
607 AccessTokenID tokenId2 = 537919486; // 537919486: 001 00 0 000000 11111111111111111110
608 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
609 std::string hapUniqueKey = "com.ohos.TEST&" + std::to_string(USER_ID) + "&" + std::to_string(INST_INDEX);
610 AccessTokenInfoManager::GetInstance().hapTokenIdMap_[hapUniqueKey] = tokenId2;
611 // hapTokenIdMap_[HapUniqueKey] != id
612 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
613 AccessTokenInfoManager::GetInstance().hapTokenIdMap_.erase(hapUniqueKey);
614 }
615
616 /**
617 * @tc.name: GetHapTokenID001
618 * @tc.desc: Verify the GetHapTokenID by userID/bundleName/instIndex, function.
619 * @tc.type: FUNC
620 * @tc.require:
621 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenID001, TestSize.Level1)622 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenID001, TestSize.Level1)
623 {
624 AccessTokenIDEx tokenIdEx = {0};
625 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
626 g_infoManagerTestPolicyPrams1, tokenIdEx);
627 ASSERT_EQ(RET_SUCCESS, ret);
628 GTEST_LOG_(INFO) << "add a hap token";
629
630 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
631 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
632 AccessTokenID getTokenId = tokenIdEx.tokenIdExStruct.tokenID;
633 ASSERT_EQ(tokenIdEx.tokenIdExStruct.tokenID, getTokenId);
634 GTEST_LOG_(INFO) << "find hap info";
635
636 std::shared_ptr<HapTokenInfoInner> tokenInfo;
637 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
638 ASSERT_NE(nullptr, tokenInfo);
639 GTEST_LOG_(INFO) << "remove the token info";
640
641 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
642 ASSERT_EQ(RET_SUCCESS, ret);
643 GTEST_LOG_(INFO) << "remove the token info";
644 }
645
646 /**
647 * @tc.name: UpdateHapToken001
648 * @tc.desc: Verify the UpdateHapToken token function.
649 * @tc.type: FUNC
650 * @tc.require:
651 */
HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken001, TestSize.Level1)652 HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken001, TestSize.Level1)
653 {
654 AccessTokenIDEx tokenIdEx = {0};
655 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
656 g_infoManagerTestPolicyPrams1, tokenIdEx);
657 ASSERT_EQ(RET_SUCCESS, ret);
658 GTEST_LOG_(INFO) << "add a hap token";
659
660 HapPolicyParams policy = g_infoManagerTestPolicyPrams1;
661 policy.apl = APL_SYSTEM_BASIC;
662 UpdateHapInfoParams info;
663 info.appIDDesc = std::string("updateAppId");
664 info.apiVersion = DEFAULT_API_VERSION;
665 info.isSystemApp = false;
666 ret = AccessTokenInfoManager::GetInstance().UpdateHapToken(
667 tokenIdEx, info, policy.permStateList, policy.apl, policy.permList);
668 ASSERT_EQ(RET_SUCCESS, ret);
669 GTEST_LOG_(INFO) << "update the hap token";
670
671 std::shared_ptr<HapTokenInfoInner> tokenInfo;
672 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
673 ASSERT_NE(nullptr, tokenInfo);
674 std::string infoDes;
675 tokenInfo->ToString(infoDes);
676 GTEST_LOG_(INFO) << "get hap token info:" << infoDes.c_str();
677
678 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
679 ASSERT_EQ(RET_SUCCESS, ret);
680 GTEST_LOG_(INFO) << "remove the token info";
681 }
682
683 /**
684 * @tc.name: UpdateHapToken002
685 * @tc.desc: Verify the UpdateHapToken token function abnormal branch.
686 * @tc.type: FUNC
687 * @tc.require:
688 */
HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken002, TestSize.Level1)689 HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken002, TestSize.Level1)
690 {
691 AccessTokenIDEx tokenIdEx = {0};
692 HapPolicyParams policy = g_infoManagerTestPolicyPrams1;
693 policy.apl = APL_SYSTEM_BASIC;
694 UpdateHapInfoParams info;
695 info.appIDDesc = std::string("");
696 info.apiVersion = DEFAULT_API_VERSION;
697 info.isSystemApp = false;
698 int ret = AccessTokenInfoManager::GetInstance().UpdateHapToken(
699 tokenIdEx, info, policy.permStateList, policy.apl, policy.permList);
700 ASSERT_EQ(ERR_PARAM_INVALID, ret);
701
702 info.appIDDesc = std::string("updateAppId");
703 ret = AccessTokenInfoManager::GetInstance().UpdateHapToken(
704 tokenIdEx, info, policy.permStateList, policy.apl, policy.permList);
705 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, ret);
706 }
707
708 /**
709 * @tc.name: UpdateHapToken003
710 * @tc.desc: AccessTokenInfoManager::UpdateHapToken function test IsRemote_ true
711 * @tc.type: FUNC
712 * @tc.require:
713 */
HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken003, TestSize.Level1)714 HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken003, TestSize.Level1)
715 {
716 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
717 AccessTokenIDEx tokenIdEx = {0};
718 tokenIdEx.tokenIdExStruct.tokenID = tokenId;
719 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
720 info->isRemote_ = true;
721 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
722 HapPolicyParams policy;
723 UpdateHapInfoParams hapInfoParams;
724 hapInfoParams.appIDDesc = "who cares";
725 hapInfoParams.apiVersion = DEFAULT_API_VERSION;
726 hapInfoParams.isSystemApp = false;
727 ASSERT_EQ(ERR_IDENTITY_CHECK_FAILED, AccessTokenInfoManager::GetInstance().UpdateHapToken(
728 tokenIdEx, hapInfoParams, policy.permStateList, policy.apl, policy.permList));
729 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
730 }
731
732 #ifdef TOKEN_SYNC_ENABLE
733 /**
734 * @tc.name: GetHapTokenSync001
735 * @tc.desc: Verify the GetHapTokenSync token function and abnormal branch.
736 * @tc.type: FUNC
737 * @tc.require:
738 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenSync001, TestSize.Level1)739 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenSync001, TestSize.Level1)
740 {
741 AccessTokenIDEx tokenIdEx = {0};
742 int result;
743 result = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
744 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
745 ASSERT_EQ(RET_SUCCESS, result);
746 GTEST_LOG_(INFO) << "add a hap token";
747
748 HapTokenInfoForSync hapSync;
749 result = AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
750 ASSERT_EQ(result, RET_SUCCESS);
751
752 result = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
753 ASSERT_EQ(RET_SUCCESS, result);
754 GTEST_LOG_(INFO) << "remove the token info";
755
756 result = AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
757 ASSERT_NE(result, RET_SUCCESS);
758 }
759
760 /**
761 * @tc.name: GetHapTokenSync002
762 * @tc.desc: AccessTokenInfoManager::GetHapTokenSync function test permSetPtr is null
763 * @tc.type: FUNC
764 * @tc.require:
765 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenSync002, TestSize.Level1)766 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenSync002, TestSize.Level1)
767 {
768 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
769 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
770 info->permPolicySet_ = nullptr;
771 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
772 HapTokenInfoForSync hapSync;
773 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenId, hapSync));
774 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
775 }
776
777 /**
778 * @tc.name: GetHapTokenInfoFromRemote001
779 * @tc.desc: Verify the GetHapTokenInfoFromRemote token function .
780 * @tc.type: FUNC
781 * @tc.require:
782 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenInfoFromRemote001, TestSize.Level1)783 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
784 {
785 AccessTokenIDEx tokenIdEx = {0};
786 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
787 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
788 ASSERT_EQ(RET_SUCCESS, ret);
789 GTEST_LOG_(INFO) << "add a hap token";
790
791 HapTokenInfoForSync hapSync;
792 ret = AccessTokenInfoManager::GetInstance().GetHapTokenInfoFromRemote(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
793 ASSERT_EQ(ret, RET_SUCCESS);
794
795 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
796 ASSERT_EQ(RET_SUCCESS, ret);
797 GTEST_LOG_(INFO) << "remove the token info";
798 }
799
800 /**
801 * @tc.name: RemoteHapTest001001
802 * @tc.desc: Verify the RemoteHap token function .
803 * @tc.type: FUNC
804 * @tc.require: issueI5RJBB
805 */
HWTEST_F(AccessTokenInfoManagerTest, RemoteHapTest001, TestSize.Level1)806 HWTEST_F(AccessTokenInfoManagerTest, RemoteHapTest001, TestSize.Level1)
807 {
808 AccessTokenIDEx tokenIdEx = {0};
809 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
810 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
811 ASSERT_EQ(RET_SUCCESS, ret);
812 GTEST_LOG_(INFO) << "add a hap token";
813
814 std::string deviceId = "device_1";
815 std::string deviceId2 = "device_2";
816 AccessTokenID mapID =
817 AccessTokenInfoManager::GetInstance().AllocLocalTokenID(deviceId, tokenIdEx.tokenIdExStruct.tokenID);
818 ASSERT_EQ(mapID, 0);
819 HapTokenInfoForSync hapSync;
820 ret = AccessTokenInfoManager::GetInstance().GetHapTokenInfoFromRemote(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
821 ASSERT_EQ(RET_SUCCESS, ret);
822 ret = AccessTokenInfoManager::GetInstance().SetRemoteHapTokenInfo(deviceId, hapSync);
823 ASSERT_EQ(RET_SUCCESS, ret);
824 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteDeviceTokens(deviceId);
825 ASSERT_EQ(RET_SUCCESS, ret);
826 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteDeviceTokens(deviceId2);
827 ASSERT_EQ(ERR_DEVICE_NOT_EXIST, ret);
828
829 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
830 ASSERT_EQ(RET_SUCCESS, ret);
831 GTEST_LOG_(INFO) << "remove the token info";
832 }
833
834 /**
835 * @tc.name: DeleteRemoteToken001
836 * @tc.desc: Verify the DeleteRemoteToken normal and abnormal branch.
837 * @tc.type: FUNC
838 * @tc.require: issueI5RJBB
839 */
HWTEST_F(AccessTokenInfoManagerTest, DeleteRemoteToken001, TestSize.Level1)840 HWTEST_F(AccessTokenInfoManagerTest, DeleteRemoteToken001, TestSize.Level1)
841 {
842 AccessTokenIDEx tokenIdEx = {0};
843 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
844 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
845 ASSERT_EQ(RET_SUCCESS, ret);
846 GTEST_LOG_(INFO) << "add a hap token";
847
848 std::string deviceId = "device_1";
849 std::string deviceId2 = "device_2";
850 AccessTokenID mapId =
851 AccessTokenInfoManager::GetInstance().AllocLocalTokenID(deviceId, tokenIdEx.tokenIdExStruct.tokenID);
852 ASSERT_EQ(mapId == 0, true);
853 HapTokenInfoForSync hapSync;
854 ret = AccessTokenInfoManager::GetInstance().GetHapTokenInfoFromRemote(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
855 ASSERT_EQ(RET_SUCCESS, ret);
856 ret = AccessTokenInfoManager::GetInstance().SetRemoteHapTokenInfo(deviceId, hapSync);
857 ASSERT_EQ(RET_SUCCESS, ret);
858 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceId, tokenIdEx.tokenIdExStruct.tokenID);
859 ASSERT_EQ(RET_SUCCESS, ret);
860 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceId2, tokenIdEx.tokenIdExStruct.tokenID);
861 ASSERT_NE(RET_SUCCESS, ret);
862
863 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
864 ASSERT_EQ(RET_SUCCESS, ret);
865 GTEST_LOG_(INFO) << "remove the token info";
866 }
867
SetRemoteHapTokenInfoTest(const std::string& deviceID, const HapTokenInfo& baseInfo)868 static bool SetRemoteHapTokenInfoTest(const std::string& deviceID, const HapTokenInfo& baseInfo)
869 {
870 std::vector<PermissionStateFull> permStateList;
871 permStateList.emplace_back(g_infoManagerTestState1);
872 HapTokenInfoForSync remoteTokenInfo = {
873 .baseInfo = baseInfo,
874 .permStateList = permStateList
875 };
876
877 return RET_SUCCESS == AccessTokenInfoManager::GetInstance().SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
878 }
879
880 /**
881 * @tc.name: SetRemoteHapTokenInfo001
882 * @tc.desc: set remote hap token info, token info is wrong
883 * @tc.type: FUNC
884 * @tc.require: issue5RJBB
885 */
HWTEST_F(AccessTokenInfoManagerTest, SetRemoteHapTokenInfo001, TestSize.Level1)886 HWTEST_F(AccessTokenInfoManagerTest, SetRemoteHapTokenInfo001, TestSize.Level1)
887 {
888 std::string deviceID = "deviceId";
889 HapTokenInfo rightBaseInfo = {
890 .apl = APL_NORMAL,
891 .ver = 1,
892 .userID = 1,
893 .bundleName = "com.ohos.access_token",
894 .instIndex = 1,
895 .appID = "testtesttesttest",
896 .deviceID = "deviceId",
897 .tokenID = 0x20100000,
898 .tokenAttr = 0
899 };
900 HapTokenInfo wrongBaseInfo = rightBaseInfo;
901 std::string wrongStr(10241, 'x');
902
903 EXPECT_EQ(false, SetRemoteHapTokenInfoTest("", wrongBaseInfo));
904
905 wrongBaseInfo.apl = (ATokenAplEnum)11; // wrong apl
906 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
907
908 wrongBaseInfo = rightBaseInfo;
909 wrongBaseInfo.deviceID = wrongStr; // wrong deviceID
910 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
911
912 wrongBaseInfo = rightBaseInfo;
913 wrongBaseInfo.userID = -1; // wrong userID
914 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
915
916 wrongBaseInfo = rightBaseInfo;
917 wrongBaseInfo.bundleName = wrongStr; // wrong bundleName
918 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
919
920 wrongBaseInfo = rightBaseInfo;
921 wrongBaseInfo.tokenID = 0; // wrong tokenID
922 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
923
924 wrongBaseInfo = rightBaseInfo;
925 wrongBaseInfo.appID = wrongStr; // wrong appID
926 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
927
928 wrongBaseInfo = rightBaseInfo;
929 wrongBaseInfo.dlpType = (HapDlpType)11; // wrong dlpType
930 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
931
932 wrongBaseInfo = rightBaseInfo;
933 wrongBaseInfo.ver = 2; // 2: wrong version
934 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
935
936 wrongBaseInfo = rightBaseInfo;
937 wrongBaseInfo.tokenID = AccessTokenInfoManager::GetInstance().GetNativeTokenId("hdcd");
938 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
939 }
940
941 /**
942 * @tc.name: ClearUserGrantedPermissionState001
943 * @tc.desc: AccessTokenInfoManagerTest::ClearUserGrantedPermissionState function test
944 * @tc.type: FUNC
945 * @tc.require:
946 */
HWTEST_F(AccessTokenInfoManagerTest, ClearUserGrantedPermissionState001, TestSize.Level1)947 HWTEST_F(AccessTokenInfoManagerTest, ClearUserGrantedPermissionState001, TestSize.Level1)
948 {
949 AccessTokenID tokenId = 123; // 123 is random input
950
951 std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>();
952 ASSERT_NE(nullptr, hap);
953 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = hap;
954
955 AccessTokenInfoManager::GetInstance().ClearUserGrantedPermissionState(tokenId); // permPolicySet is null
956
957 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
958 }
959
960 /**
961 * @tc.name: NotifyTokenSyncTask001
962 * @tc.desc: TokenModifyNotifier::NotifyTokenSyncTask function test
963 * @tc.type: FUNC
964 * @tc.require:
965 */
HWTEST_F(AccessTokenInfoManagerTest, NotifyTokenSyncTask001, TestSize.Level1)966 HWTEST_F(AccessTokenInfoManagerTest, NotifyTokenSyncTask001, TestSize.Level1)
967 {
968 std::vector<AccessTokenID> modifiedTokenList = TokenModifyNotifier::GetInstance().modifiedTokenList_; // backup
969 TokenModifyNotifier::GetInstance().modifiedTokenList_.clear();
970
971 AccessTokenID tokenId = 123; // 123 is random input
972
973 TokenModifyNotifier::GetInstance().modifiedTokenList_.emplace_back(tokenId);
974 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().modifiedTokenList_.size() > 0);
975 TokenModifyNotifier::GetInstance().NotifyTokenSyncTask();
976
977 TokenModifyNotifier::GetInstance().modifiedTokenList_ = modifiedTokenList; // recovery
978 }
979
980 /**
981 * @tc.name: RegisterTokenSyncCallback001
982 * @tc.desc: TokenModifyNotifier::RegisterTokenSyncCallback function test
983 * @tc.type: FUNC
984 * @tc.require:
985 */
HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenSyncCallback001, TestSize.Level1)986 HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenSyncCallback001, TestSize.Level1)
987 {
988 setuid(3020);
989 sptr<TokenSyncCallbackMock> callback = new (std::nothrow) TokenSyncCallbackMock();
990 ASSERT_NE(nullptr, callback);
991 EXPECT_EQ(RET_SUCCESS,
992 atManagerService_->RegisterTokenSyncCallback(callback->AsObject()));
993 EXPECT_NE(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_);
994 EXPECT_NE(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackDeathRecipient_);
995
996 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_)).WillOnce(testing::Return(FAKE_SYNC_RET));
997 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_->GetRemoteHapTokenInfo("", 0));
998
999 EXPECT_CALL(*callback, DeleteRemoteHapTokenInfo(testing::_)).WillOnce(testing::Return(FAKE_SYNC_RET));
1000 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_->DeleteRemoteHapTokenInfo(0));
1001
1002 HapTokenInfoForSync tokenInfo;
1003 EXPECT_CALL(*callback, UpdateRemoteHapTokenInfo(testing::_)).WillOnce(testing::Return(FAKE_SYNC_RET));
1004 EXPECT_EQ(FAKE_SYNC_RET,
1005 TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_->UpdateRemoteHapTokenInfo(tokenInfo));
1006 EXPECT_EQ(RET_SUCCESS,
1007 atManagerService_->UnRegisterTokenSyncCallback());
1008 EXPECT_EQ(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_);
1009 EXPECT_EQ(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackDeathRecipient_);
1010 setuid(0);
1011 }
1012
1013 /**
1014 * @tc.name: RegisterTokenSyncCallback002
1015 * @tc.desc: TokenModifyNotifier::RegisterTokenSyncCallback function test
1016 * @tc.type: FUNC
1017 * @tc.require:
1018 */
HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenSyncCallback002, TestSize.Level1)1019 HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenSyncCallback002, TestSize.Level1)
1020 {
1021 setuid(3020);
1022 sptr<TokenSyncCallbackMock> callback = new (std::nothrow) TokenSyncCallbackMock();
1023 ASSERT_NE(nullptr, callback);
1024 EXPECT_EQ(RET_SUCCESS,
1025 atManagerService_->RegisterTokenSyncCallback(callback->AsObject()));
1026 EXPECT_NE(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_);
1027 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_))
1028 .WillOnce(testing::Return(FAKE_SYNC_RET));
1029 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance().GetRemoteHapTokenInfo("", 0));
1030
1031 std::vector<AccessTokenID> modifiedTokenList =
1032 TokenModifyNotifier::GetInstance().modifiedTokenList_; // backup
1033 std::vector<AccessTokenID> deleteTokenList = TokenModifyNotifier::GetInstance().deleteTokenList_;
1034 TokenModifyNotifier::GetInstance().modifiedTokenList_.clear();
1035 TokenModifyNotifier::GetInstance().deleteTokenList_.clear();
1036
1037 // add a hap token
1038 AccessTokenIDEx tokenIdEx = {123};
1039 int32_t result = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
1040 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
1041 EXPECT_EQ(RET_SUCCESS, result);
1042
1043 HapTokenInfoForSync hapSync;
1044 result = AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
1045 ASSERT_EQ(result, RET_SUCCESS);
1046 TokenModifyNotifier::GetInstance().modifiedTokenList_.emplace_back(tokenIdEx.tokenIdExStruct.tokenID);
1047 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().modifiedTokenList_.size() > 0);
1048 TokenModifyNotifier::GetInstance().deleteTokenList_.clear();
1049
1050 EXPECT_CALL(*callback, UpdateRemoteHapTokenInfo(testing::_)) // 0 is a test ret
1051 .WillOnce(testing::Return(0));
1052 TokenModifyNotifier::GetInstance().NotifyTokenSyncTask();
1053
1054 TokenModifyNotifier::GetInstance().deleteTokenList_.emplace_back(tokenIdEx.tokenIdExStruct.tokenID);
1055 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().deleteTokenList_.size() > 0);
1056 EXPECT_CALL(*callback, DeleteRemoteHapTokenInfo(testing::_)) // 0 is a test ret
1057 .WillOnce(testing::Return(0));
1058 TokenModifyNotifier::GetInstance().NotifyTokenSyncTask();
1059
1060 TokenModifyNotifier::GetInstance().modifiedTokenList_ = modifiedTokenList; // recovery
1061 TokenModifyNotifier::GetInstance().deleteTokenList_ = deleteTokenList;
1062 EXPECT_EQ(RET_SUCCESS,
1063 atManagerService_->UnRegisterTokenSyncCallback());
1064 setuid(0);
1065 }
1066
1067 /**
1068 * @tc.name: GetRemoteHapTokenInfo001
1069 * @tc.desc: TokenModifyNotifier::GetRemoteHapTokenInfo function test
1070 * @tc.type: FUNC
1071 * @tc.require:
1072 */
HWTEST_F(AccessTokenInfoManagerTest, GetRemoteHapTokenInfo001, TestSize.Level1)1073 HWTEST_F(AccessTokenInfoManagerTest, GetRemoteHapTokenInfo001, TestSize.Level1)
1074 {
1075 setuid(3020);
1076 sptr<TokenSyncCallbackMock> callback = new (std::nothrow) TokenSyncCallbackMock();
1077 ASSERT_NE(nullptr, callback);
1078 EXPECT_EQ(RET_SUCCESS, atManagerService_->RegisterTokenSyncCallback(callback->AsObject()));
1079 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_))
1080 .WillOnce(testing::Return(FAKE_SYNC_RET));
1081 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance()
1082 .GetRemoteHapTokenInfo("invalid_id", 0)); // this is a test input
1083
1084 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_))
1085 .WillOnce(testing::Return(TOKEN_SYNC_OPENSOURCE_DEVICE));
1086 EXPECT_EQ(TOKEN_SYNC_IPC_ERROR, TokenModifyNotifier::GetInstance()
1087 .GetRemoteHapTokenInfo("invalid_id", 0)); // this is a test input
1088 EXPECT_EQ(RET_SUCCESS,
1089 atManagerService_->UnRegisterTokenSyncCallback());
1090 setuid(0);
1091 }
1092
1093 /**
1094 * @tc.name: UpdateRemoteHapTokenInfo001
1095 * @tc.desc: AccessTokenInfoManager::UpdateRemoteHapTokenInfo function test
1096 * @tc.type: FUNC
1097 * @tc.require:
1098 */
HWTEST_F(AccessTokenInfoManagerTest, UpdateRemoteHapTokenInfo001, TestSize.Level1)1099 HWTEST_F(AccessTokenInfoManagerTest, UpdateRemoteHapTokenInfo001, TestSize.Level1)
1100 {
1101 AccessTokenID mapID = 0;
1102 HapTokenInfoForSync hapSync;
1103
1104 // infoPtr is null
1105 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().UpdateRemoteHapTokenInfo(mapID, hapSync));
1106
1107 mapID = 123; // 123 is random input
1108 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
1109 info->SetRemote(true);
1110 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[mapID] = info;
1111
1112 // remote is true
1113 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().UpdateRemoteHapTokenInfo(mapID, hapSync));
1114
1115 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(mapID);
1116 }
1117
1118 /**
1119 * @tc.name: CreateRemoteHapTokenInfo001
1120 * @tc.desc: AccessTokenInfoManager::CreateRemoteHapTokenInfo function test
1121 * @tc.type: FUNC
1122 * @tc.require:
1123 */
HWTEST_F(AccessTokenInfoManagerTest, CreateRemoteHapTokenInfo001, TestSize.Level1)1124 HWTEST_F(AccessTokenInfoManagerTest, CreateRemoteHapTokenInfo001, TestSize.Level1)
1125 {
1126 AccessTokenID mapID = 123; // 123 is random input
1127 HapTokenInfoForSync hapSync;
1128
1129 hapSync.baseInfo.tokenID = 123; // 123 is random input
1130 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
1131 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[123] = info;
1132
1133 // count(id) exsit
1134 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateRemoteHapTokenInfo(mapID, hapSync));
1135
1136 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(123);
1137 }
1138
1139 /**
1140 * @tc.name: DeleteRemoteToken002
1141 * @tc.desc: AccessTokenInfoManager::DeleteRemoteToken function test
1142 * @tc.type: FUNC
1143 * @tc.require:
1144 */
HWTEST_F(AccessTokenInfoManagerTest, DeleteRemoteToken002, TestSize.Level1)1145 HWTEST_F(AccessTokenInfoManagerTest, DeleteRemoteToken002, TestSize.Level1)
1146 {
1147 std::string deviceID = "dev-001";
1148 AccessTokenID tokenID = 123; // 123 is random input
1149
1150 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID,
1151 AccessTokenInfoManager::GetInstance().DeleteRemoteToken("", tokenID));
1152
1153 AccessTokenRemoteDevice device;
1154 device.deviceID_ = deviceID;
1155 // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
1156 device.MappingTokenIDPairMap_.insert(std::pair<AccessTokenID, AccessTokenID>(tokenID, 537919487));
1157 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_[deviceID] = device;
1158
1159 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(537919487, TOKEN_HAP));
1160 // hap mapID 537919487 is not exist
1161 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceID, tokenID));
1162 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.erase(deviceID);
1163 AccessTokenIDManager::GetInstance().ReleaseTokenId(537919487);
1164
1165 // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
1166 device.MappingTokenIDPairMap_[tokenID] = 672137215;
1167 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_[deviceID] = device;
1168
1169 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(672137215, TOKEN_NATIVE));
1170 // native mapID 672137215 is not exist
1171 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceID, tokenID));
1172 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.erase(deviceID);
1173 AccessTokenIDManager::GetInstance().ReleaseTokenId(672137215);
1174 }
1175
1176 /**
1177 * @tc.name: AllocLocalTokenID001
1178 * @tc.desc: AccessTokenInfoManager::AllocLocalTokenID function test
1179 * @tc.type: FUNC
1180 * @tc.require:
1181 */
HWTEST_F(AccessTokenInfoManagerTest, AllocLocalTokenID001, TestSize.Level1)1182 HWTEST_F(AccessTokenInfoManagerTest, AllocLocalTokenID001, TestSize.Level1)
1183 {
1184 std::string remoteDeviceID;
1185 AccessTokenID remoteTokenID = 0;
1186
1187 ASSERT_EQ(static_cast<AccessTokenID>(0), AccessTokenInfoManager::GetInstance().AllocLocalTokenID(remoteDeviceID,
1188 remoteTokenID)); // remoteDeviceID invalid
1189
1190 // deviceID invalid + tokenID == 0
1191 ASSERT_EQ(static_cast<AccessTokenID>(0),
1192 AccessTokenInfoManager::GetInstance().GetRemoteNativeTokenID(remoteDeviceID, remoteTokenID));
1193
1194 // deviceID invalid
1195 ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().DeleteRemoteDeviceTokens(remoteDeviceID));
1196
1197 remoteDeviceID = "dev-001";
1198 ASSERT_EQ(static_cast<AccessTokenID>(0), AccessTokenInfoManager::GetInstance().AllocLocalTokenID(remoteDeviceID,
1199 remoteTokenID)); // remoteTokenID invalid
1200
1201 // deviceID valid + tokenID == 0
1202 ASSERT_EQ(static_cast<AccessTokenID>(0),
1203 AccessTokenInfoManager::GetInstance().GetRemoteNativeTokenID(remoteDeviceID, remoteTokenID));
1204
1205 remoteTokenID = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
1206 // deviceID valid + tokenID != 0 + type != native + type != shell
1207 ASSERT_EQ(static_cast<AccessTokenID>(0),
1208 AccessTokenInfoManager::GetInstance().GetRemoteNativeTokenID(remoteDeviceID, remoteTokenID));
1209 }
1210 #endif
1211
1212 /**
1213 * @tc.name: Dump001
1214 * @tc.desc: Dump tokeninfo.
1215 * @tc.type: FUNC
1216 * @tc.require: issueI4V02P
1217 */
HWTEST_F(AccessTokenInfoManagerTest, Dump001, TestSize.Level1)1218 HWTEST_F(AccessTokenInfoManagerTest, Dump001, TestSize.Level1)
1219 {
1220 int fd = -1;
1221 std::vector<std::u16string> args;
1222
1223 // fd is 0
1224 ASSERT_NE(RET_SUCCESS, atManagerService_->Dump(fd, args));
1225
1226 fd = 123; // 123：valid fd
1227
1228 // hidumper
1229 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1230
1231 // hidumper -h
1232 args.emplace_back(Str8ToStr16("-h"));
1233 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1234
1235 args.clear();
1236 // hidumper -a
1237 args.emplace_back(Str8ToStr16("-a"));
1238 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1239
1240 args.clear();
1241 // hidumper -t
1242 args.emplace_back(Str8ToStr16("-t"));
1243 ASSERT_NE(RET_SUCCESS, atManagerService_->Dump(fd, args));
1244
1245 args.clear();
1246 // hidumper -t
1247 args.emplace_back(Str8ToStr16("-t"));
1248 args.emplace_back(Str8ToStr16("-1")); // illegal tokenId
1249 ASSERT_NE(RET_SUCCESS, atManagerService_->Dump(fd, args));
1250
1251 args.clear();
1252 // hidumper -t
1253 args.emplace_back(Str8ToStr16("-t"));
1254 args.emplace_back(Str8ToStr16("123")); // invalid tokenId
1255 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1256 }
1257
1258 /**
1259 * @tc.name: DumpTokenInfo001
1260 * @tc.desc: Test DumpTokenInfo with invalid tokenId.
1261 * @tc.type: FUNC
1262 * @tc.require: issueI4V02P
1263 */
HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo001, TestSize.Level1)1264 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo001, TestSize.Level1)
1265 {
1266 std::string dumpInfo;
1267 AtmToolsParamInfo info;
1268 info.tokenId = static_cast<AccessTokenID>(0);
1269 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1270 EXPECT_EQ(false, dumpInfo.empty());
1271
1272 dumpInfo.clear();
1273 info.tokenId = static_cast<AccessTokenID>(123);
1274 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1275 EXPECT_EQ("invalid tokenId", dumpInfo);
1276 }
1277
1278 /**
1279 * @tc.name: DumpTokenInfo002
1280 * @tc.desc: Test DumpTokenInfo with hap tokenId.
1281 * @tc.type: FUNC
1282 * @tc.require: issueI4V02P
1283 */
HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo002, TestSize.Level1)1284 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo002, TestSize.Level1)
1285 {
1286 AccessTokenIDEx tokenIdEx = {0};
1287 AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
1288 g_infoManagerTestPolicyPrams1, tokenIdEx);
1289
1290 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
1291 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
1292 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1293 EXPECT_NE(0, static_cast<int>(tokenId));
1294 std::string dumpInfo;
1295 AtmToolsParamInfo info;
1296 info.tokenId = tokenId;
1297 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1298 EXPECT_EQ(false, dumpInfo.empty());
1299
1300 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(
1301 tokenIdEx.tokenIdExStruct.tokenID);
1302 ASSERT_EQ(RET_SUCCESS, ret);
1303 GTEST_LOG_(INFO) << "remove the token info";
1304 }
1305
1306 /**
1307 * @tc.name: DumpTokenInfo003
1308 * @tc.desc: Test DumpTokenInfo with native tokenId.
1309 * @tc.type: FUNC
1310 * @tc.require: issueI4V02P
1311 */
HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo003, TestSize.Level1)1312 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo003, TestSize.Level1)
1313 {
1314 std::string dumpInfo;
1315 AtmToolsParamInfo info;
1316 info.tokenId = AccessTokenInfoManager::GetInstance().GetNativeTokenId("accesstoken_service");
1317 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1318 EXPECT_EQ(false, dumpInfo.empty());
1319 }
1320
1321 /**
1322 * @tc.name: DumpTokenInfo004
1323 * @tc.desc: Test DumpTokenInfo with shell tokenId.
1324 * @tc.type: FUNC
1325 * @tc.require: issueI4V02P
1326 */
HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo004, TestSize.Level1)1327 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo004, TestSize.Level1)
1328 {
1329 std::string dumpInfo;
1330 AtmToolsParamInfo info;
1331 info.tokenId = AccessTokenInfoManager::GetInstance().GetNativeTokenId("hdcd");
1332 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1333 EXPECT_EQ(false, dumpInfo.empty());
1334 }
1335
1336 /**
1337 * @tc.name: DumpTokenInfo006
1338 * @tc.desc: Test DumpTokenInfo with native processName.
1339 * @tc.type: FUNC
1340 * @tc.require: issueI4V02P
1341 */
HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo006, TestSize.Level1)1342 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo006, TestSize.Level1)
1343 {
1344 std::string dumpInfo;
1345 AtmToolsParamInfo info;
1346 info.processName = "hdcd";
1347 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1348 EXPECT_EQ(false, dumpInfo.empty());
1349 }
1350
1351 /**
1352 * @tc.name: DumpTokenInfo007
1353 * @tc.desc: Test DumpTokenInfo with hap bundleName.
1354 * @tc.type: FUNC
1355 * @tc.require: issueI4V02P
1356 */
HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo007, TestSize.Level1)1357 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo007, TestSize.Level1)
1358 {
1359 AccessTokenIDEx tokenIdEx = {0};
1360 AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
1361 g_infoManagerTestPolicyPrams1, tokenIdEx);
1362
1363 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
1364 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
1365 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1366 EXPECT_NE(0, static_cast<int>(tokenId));
1367
1368 std::string dumpInfo;
1369 AtmToolsParamInfo info;
1370 info.bundleName = g_infoManagerTestInfoParms.bundleName;
1371 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1372 EXPECT_EQ(false, dumpInfo.empty());
1373
1374 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(
1375 tokenIdEx.tokenIdExStruct.tokenID);
1376 ASSERT_EQ(RET_SUCCESS, ret);
1377 }
1378
1379 /**
1380 * @tc.name: AccessTokenInfoManager001
1381 * @tc.desc: AccessTokenInfoManager::~AccessTokenInfoManager+Init function test hasInited_ is false
1382 * @tc.type: FUNC
1383 * @tc.require:
1384 */
HWTEST_F(AccessTokenInfoManagerTest, AccessTokenInfoManager001, TestSize.Level1)1385 HWTEST_F(AccessTokenInfoManagerTest, AccessTokenInfoManager001, TestSize.Level1)
1386 {
1387 AccessTokenInfoManager::GetInstance().hasInited_ = true;
1388 AccessTokenInfoManager::GetInstance().Init();
1389 AccessTokenInfoManager::GetInstance().hasInited_ = false;
1390 ASSERT_EQ(false, AccessTokenInfoManager::GetInstance().hasInited_);
1391 }
1392
1393 /**
1394 * @tc.name: GetHapUniqueStr001
1395 * @tc.desc: AccessTokenInfoManager::GetHapUniqueStr function test info is null
1396 * @tc.type: FUNC
1397 * @tc.require:
1398 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapUniqueStr001, TestSize.Level1)1399 HWTEST_F(AccessTokenInfoManagerTest, GetHapUniqueStr001, TestSize.Level1)
1400 {
1401 std::shared_ptr<HapTokenInfoInner> info = nullptr;
1402 ASSERT_EQ("", AccessTokenInfoManager::GetInstance().GetHapUniqueStr(info));
1403 }
1404
1405 /**
1406 * @tc.name: AddHapTokenInfo001
1407 * @tc.desc: AccessTokenInfoManager::AddHapTokenInfo function test info is null
1408 * @tc.type: FUNC
1409 * @tc.require:
1410 */
HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenInfo001, TestSize.Level1)1411 HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenInfo001, TestSize.Level1)
1412 {
1413 std::shared_ptr<HapTokenInfoInner> info = nullptr;
1414 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().AddHapTokenInfo(info));
1415 }
1416
1417 /**
1418 * @tc.name: AddHapTokenInfo002
1419 * @tc.desc: AccessTokenInfoManager::AddHapTokenInfo function test count(id) > 0
1420 * @tc.type: FUNC
1421 * @tc.require:
1422 */
HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenInfo002, TestSize.Level1)1423 HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenInfo002, TestSize.Level1)
1424 {
1425 HapInfoParams info = {
1426 .userID = USER_ID,
1427 .bundleName = "accesstoken_info_manager_test",
1428 .instIndex = INST_INDEX,
1429 .appIDDesc = "accesstoken_info_manager_test"
1430 };
1431 HapPolicyParams policy = {
1432 .apl = APL_NORMAL,
1433 .domain = "domain"
1434 };
1435 AccessTokenIDEx tokenIdEx = {0};
1436 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
1437 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1438 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
1439
1440 std::shared_ptr<HapTokenInfoInner> infoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
1441 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().AddHapTokenInfo(infoPtr));
1442
1443 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
1444 }
1445
1446 /**
1447 * @tc.name: GetHapTokenID002
1448 * @tc.desc: test GetHapTokenID function abnomal branch
1449 * @tc.type: FUNC
1450 * @tc.require: issueI60F1M
1451 */
HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenID002, TestSize.Level1)1452 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenID002, TestSize.Level1)
1453 {
1454 AccessTokenIDEx tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(
1455 USER_ID, "com.ohos.test", INST_INDEX);
1456 ASSERT_EQ(static_cast<AccessTokenID>(0), tokenIdEx.tokenIDEx);
1457 }
1458
1459 /**
1460 * @tc.name: AddNativeTokenInfo001
1461 * @tc.desc: AccessTokenInfoManager::AddNativeTokenInfo function test
1462 * @tc.type: FUNC
1463 * @tc.require: issueI62M6G
1464 */
HWTEST_F(AccessTokenInfoManagerTest, AddNativeTokenInfo001, TestSize.Level1)1465 HWTEST_F(AccessTokenInfoManagerTest, AddNativeTokenInfo001, TestSize.Level1)
1466 {
1467 std::shared_ptr<NativeTokenInfoInner> info = nullptr;
1468 ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(info)); // info is null
1469
1470 AccessTokenID tokenId = AccessTokenInfoManager::GetInstance().GetNativeTokenId("accesstoken_service");
1471 info = std::make_shared<NativeTokenInfoInner>();
1472 info->tokenInfoBasic_.tokenID = tokenId;
1473 ASSERT_EQ(ERR_TOKENID_HAS_EXISTED, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(info)); // count(id) > 0
1474 }
1475
1476 /**
1477 * @tc.name: RemoveNativeTokenInfo001
1478 * @tc.desc: AccessTokenInfoManager::RemoveNativeTokenInfo function test
1479 * @tc.type: FUNC
1480 * @tc.require: issueI62M6G
1481 */
HWTEST_F(AccessTokenInfoManagerTest, RemoveNativeTokenInfo001, TestSize.Level1)1482 HWTEST_F(AccessTokenInfoManagerTest, RemoveNativeTokenInfo001, TestSize.Level1)
1483 {
1484 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
1485 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
1486 ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId));
1487
1488 tokenId = 806354943; // 806354943 is shell tokenId: 001 10 0 000000 11111111111111111111
1489 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_SHELL));
1490 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId));
1491
1492 tokenId = 672137215; // 672137215 is native tokenId: 001 01 0 000000 11111111111111111111
1493
1494 std::shared_ptr<NativeTokenInfoInner> native = std::make_shared<NativeTokenInfoInner>();
1495 ASSERT_NE(nullptr, native);
1496 native->tokenInfoBasic_.apl = ATokenAplEnum::APL_SYSTEM_BASIC;
1497 native->tokenInfoBasic_.tokenID = tokenId;
1498 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_NATIVE));
1499 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(native));
1500 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId));
1501 }
1502
1503 /**
1504 * @tc.name: TryUpdateExistNativeToken001
1505 * @tc.desc: AccessTokenInfoManager::TryUpdateExistNativeToken function test
1506 * @tc.type: FUNC
1507 * @tc.require:
1508 */
HWTEST_F(AccessTokenInfoManagerTest, TryUpdateExistNativeToken001, TestSize.Level1)1509 HWTEST_F(AccessTokenInfoManagerTest, TryUpdateExistNativeToken001, TestSize.Level1)
1510 {
1511 std::shared_ptr<NativeTokenInfoInner> infoPtr = nullptr;
1512 ASSERT_EQ(false, AccessTokenInfoManager::GetInstance().TryUpdateExistNativeToken(infoPtr)); // infoPtr is null
1513 }
1514
1515 /**
1516 * @tc.name: Insert001
1517 * @tc.desc: PermissionDefinitionCache::Insert function test
1518 * @tc.type: FUNC
1519 * @tc.require:
1520 */
HWTEST_F(AccessTokenInfoManagerTest, Insert001, TestSize.Level1)1521 HWTEST_F(AccessTokenInfoManagerTest, Insert001, TestSize.Level1)
1522 {
1523 PermissionDef info = {
1524 .permissionName = "ohos.permission.CAMERA",
1525 .bundleName = "com.ohos.test",
1526 .grantMode = 0,
1527 .availableLevel = ATokenAplEnum::APL_NORMAL,
1528 .provisionEnable = false,
1529 .distributedSceneEnable = false,
1530 .label = "buzhidao",
1531 .labelId = 100, // 100 is random input
1532 .description = "buzhidao",
1533 .descriptionId = 100 // 100 is random input
1534 };
1535 AccessTokenID tokenId = 123; // 123 is random input
1536
1537 ASSERT_EQ(false, PermissionDefinitionCache::GetInstance().Insert(info, tokenId)); // permission has insert
1538 }
1539
1540 /**
1541 * @tc.name: IsGrantedModeEqualInner001
1542 * @tc.desc: PermissionDefinitionCache::IsGrantedModeEqualInner function test
1543 * @tc.type: FUNC
1544 * @tc.require:
1545 */
HWTEST_F(AccessTokenInfoManagerTest, IsGrantedModeEqualInner001, TestSize.Level1)1546 HWTEST_F(AccessTokenInfoManagerTest, IsGrantedModeEqualInner001, TestSize.Level1)
1547 {
1548 std::string permissionName = "ohos.permission.CAMERA";
1549 int grantMode = 0;
1550
1551 // find permission not reach end
1552 ASSERT_EQ(true, PermissionDefinitionCache::GetInstance().IsGrantedModeEqualInner(permissionName, grantMode));
1553
1554 permissionName = "ohos.permission.INVALID";
1555 // can't find permission
1556 ASSERT_EQ(false, PermissionDefinitionCache::GetInstance().IsGrantedModeEqualInner(permissionName, grantMode));
1557 }
1558
1559 /**
1560 * @tc.name: RestorePermDefInfo001
1561 * @tc.desc: PermissionDefinitionCache::RestorePermDefInfo function test
1562 * @tc.type: FUNC
1563 * @tc.require:
1564 */
HWTEST_F(AccessTokenInfoManagerTest, RestorePermDefInfo001, TestSize.Level1)1565 HWTEST_F(AccessTokenInfoManagerTest, RestorePermDefInfo001, TestSize.Level1)
1566 {
1567 GenericValues value;
1568 value.Put(TokenFiledConst::FIELD_AVAILABLE_LEVEL, ATokenAplEnum::APL_INVALID);
1569
1570 std::vector<GenericValues> values;
1571 values.emplace_back(value);
1572
1573 // ret not RET_SUCCESS
1574 ASSERT_NE(RET_SUCCESS, PermissionDefinitionCache::GetInstance().RestorePermDefInfo(values));
1575 }
1576
1577 /**
1578 * @tc.name: IsPermissionDefValid001
1579 * @tc.desc: PermissionValidator::IsPermissionDefValid function test
1580 * @tc.type: FUNC
1581 * @tc.require:
1582 */
HWTEST_F(AccessTokenInfoManagerTest, IsPermissionDefValid001, TestSize.Level1)1583 HWTEST_F(AccessTokenInfoManagerTest, IsPermissionDefValid001, TestSize.Level1)
1584 {
1585 PermissionDef permDef = {
1586 .permissionName = "ohos.permission.TEST",
1587 .bundleName = "com.ohos.test",
1588 .grantMode = static_cast<GrantMode>(2),
1589 .availableLevel = ATokenAplEnum::APL_NORMAL,
1590 .provisionEnable = false,
1591 .distributedSceneEnable = false,
1592 .label = "buzhidao",
1593 .labelId = 100, // 100 is random input
1594 .description = "buzhidao",
1595 .descriptionId = 100 // 100 is random input
1596 };
1597
1598 // ret not RET_SUCCESS
1599 ASSERT_EQ(false, PermissionValidator::IsPermissionDefValid(permDef)); // grant mode invalid
1600
1601 permDef.grantMode = GrantMode::USER_GRANT;
1602 permDef.availableType = ATokenAvailableTypeEnum::INVALID;
1603 ASSERT_EQ(false, PermissionValidator::IsPermissionDefValid(permDef)); // availableType invalid
1604 }
1605
1606 /**
1607 * @tc.name: IsPermissionStateValid001
1608 * @tc.desc: PermissionValidator::IsPermissionStateValid function test
1609 * @tc.type: FUNC
1610 * @tc.require:
1611 */
HWTEST_F(AccessTokenInfoManagerTest, IsPermissionStateValid001, TestSize.Level1)1612 HWTEST_F(AccessTokenInfoManagerTest, IsPermissionStateValid001, TestSize.Level1)
1613 {
1614 std::string permissionName;
1615 std::string deviceID = "dev-001";
1616 int grantState = PermissionState::PERMISSION_DENIED;
1617 uint32_t grantFlag = PermissionFlag::PERMISSION_DEFAULT_FLAG;
1618
1619 std::vector<std::string> resDeviceID;
1620 std::vector<int> grantStates;
1621 std::vector<uint32_t> grantFlags;
1622
1623 resDeviceID.emplace_back(deviceID);
1624 grantStates.emplace_back(grantState);
1625 grantFlags.emplace_back(grantFlag);
1626
1627 PermissionStateFull permState = {
1628 .permissionName = permissionName,
1629 .isGeneral = false,
1630 .resDeviceID = resDeviceID,
1631 .grantStatus = grantStates,
1632 .grantFlags = grantFlags
1633 };
1634
1635 ASSERT_EQ(false, PermissionValidator::IsPermissionStateValid(permState)); // permissionName empty
1636
1637 permState.permissionName = "com.ohos.TEST";
1638 permState.resDeviceID.emplace_back("dev-002");
1639 // deviceID nums not equal status nums or flag nums
1640 ASSERT_EQ(false, PermissionValidator::IsPermissionStateValid(permState));
1641
1642 permState.grantStatus.emplace_back(PermissionState::PERMISSION_DENIED);
1643 // deviceID nums not equal flag nums
1644 ASSERT_EQ(false, PermissionValidator::IsPermissionStateValid(permState));
1645
1646 permState.grantFlags.emplace_back(PermissionFlag::PERMISSION_DEFAULT_FLAG);
1647 ASSERT_EQ(true, PermissionValidator::IsPermissionStateValid(permState));
1648 }
1649
1650 /**
1651 * @tc.name: FilterInvalidPermissionDef001
1652 * @tc.desc: PermissionValidator::FilterInvalidPermissionDef function test
1653 * @tc.type: FUNC
1654 * @tc.require:
1655 */
HWTEST_F(AccessTokenInfoManagerTest, FilterInvalidPermissionDef001, TestSize.Level1)1656 HWTEST_F(AccessTokenInfoManagerTest, FilterInvalidPermissionDef001, TestSize.Level1)
1657 {
1658 PermissionDef permDef = {
1659 .permissionName = "ohos.permission.TEST",
1660 .bundleName = "com.ohos.test",
1661 .grantMode = GrantMode::SYSTEM_GRANT,
1662 .availableLevel = ATokenAplEnum::APL_NORMAL,
1663 .provisionEnable = false,
1664 .distributedSceneEnable = false,
1665 .label = "buzhidao",
1666 .labelId = 100, // 100 is random input
1667 .description = "buzhidao",
1668 .descriptionId = 100 // 100 is random input
1669 };
1670
1671 std::vector<PermissionDef> permList;
1672 permList.emplace_back(permDef);
1673 permList.emplace_back(permDef);
1674
1675 ASSERT_EQ(static_cast<uint32_t>(2), permList.size());
1676
1677 std::vector<PermissionDef> result;
1678 PermissionValidator::FilterInvalidPermissionDef(permList, result); // permDefSet.count != 0
1679 ASSERT_EQ(static_cast<uint32_t>(1), result.size());
1680 }
1681
1682 /**
1683 * @tc.name: DeduplicateResDevID001
1684 * @tc.desc: PermissionValidator::DeduplicateResDevID function test
1685 * @tc.type: FUNC
1686 * @tc.require:
1687 */
HWTEST_F(AccessTokenInfoManagerTest, DeduplicateResDevID001, TestSize.Level1)1688 HWTEST_F(AccessTokenInfoManagerTest, DeduplicateResDevID001, TestSize.Level1)
1689 {
1690 GTEST_LOG_(INFO) << "DeduplicateResDevID001";
1691 PermissionStateFull permState = {
1692 .permissionName = "ohos.permission.TEST",
1693 .isGeneral = false,
1694 .resDeviceID = {"dev-001", "dev-001"},
1695 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1696 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1697 };
1698 GTEST_LOG_(INFO) << "DeduplicateResDevID001_1";
1699 ASSERT_EQ(static_cast<uint32_t>(2), permState.resDeviceID.size());
1700
1701 std::vector<PermissionStateFull> permList;
1702 permList.emplace_back(permState);
1703 std::vector<PermissionStateFull> result;
1704 GTEST_LOG_(INFO) << "DeduplicateResDevID001_2";
1705 PermissionValidator::FilterInvalidPermissionState(TOKEN_NATIVE, false, permList, result); // resDevId.count != 0
1706 GTEST_LOG_(INFO) << "DeduplicateResDevID001_3";
1707 ASSERT_EQ(static_cast<uint32_t>(1), result[0].resDeviceID.size());
1708 }
1709
1710 /**
1711 * @tc.name: Update001
1712 * @tc.desc: PermissionPolicySet::Update function test
1713 * @tc.type: FUNC
1714 * @tc.require:
1715 */
HWTEST_F(AccessTokenInfoManagerTest, Update001, TestSize.Level1)1716 HWTEST_F(AccessTokenInfoManagerTest, Update001, TestSize.Level1)
1717 {
1718 PermissionStateFull perm1 = {
1719 .permissionName = "ohos.permission.TEST1",
1720 .isGeneral = false,
1721 .resDeviceID = {"dev-001", "dev-001"},
1722 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1723 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1724 };
1725 PermissionStateFull perm2 = {
1726 .permissionName = "ohos.permission.TEST2",
1727 .isGeneral = true,
1728 .resDeviceID = {"dev-001", "dev-001"},
1729 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1730 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1731 };
1732 PermissionStateFull perm3 = {
1733 .permissionName = "ohos.permission.TEST1",
1734 .isGeneral = true,
1735 .resDeviceID = {"dev-001", "dev-001"},
1736 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1737 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1738 };
1739 ASSERT_EQ(false, perm1.permissionName == perm2.permissionName);
1740 ASSERT_EQ(true, perm1.permissionName == perm3.permissionName);
1741 ASSERT_EQ(false, perm1.isGeneral == perm3.isGeneral);
1742
1743 AccessTokenID tokenId = 123; // 123 is random input
1744 std::vector<PermissionStateFull> permStateList1;
1745 permStateList1.emplace_back(perm1);
1746 std::vector<PermissionStateFull> permStateList2;
1747 permStateList1.emplace_back(perm2);
1748 std::vector<PermissionStateFull> permStateList3;
1749 permStateList1.emplace_back(perm3);
1750
1751 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1752 permStateList1);
1753
1754 policySet->Update(permStateList2); // iter reach end
1755 policySet->Update(permStateList3); // permNew.isGeneral != permOld.isGeneral
1756 }
1757
1758 /**
1759 * @tc.name: RestorePermissionPolicy001
1760 * @tc.desc: PermissionPolicySet::RestorePermissionPolicy function test
1761 * @tc.type: FUNC
1762 * @tc.require:
1763 */
HWTEST_F(AccessTokenInfoManagerTest, RestorePermissionPolicy001, TestSize.Level1)1764 HWTEST_F(AccessTokenInfoManagerTest, RestorePermissionPolicy001, TestSize.Level1)
1765 {
1766 GenericValues value1;
1767 value1.Put(TokenFiledConst::FIELD_TOKEN_ID, 123); // 123 is random input
1768 value1.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, true);
1769 value1.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
1770 value1.Put(TokenFiledConst::FIELD_DEVICE_ID, "dev-001");
1771 value1.Put(TokenFiledConst::FIELD_GRANT_STATE, static_cast<PermissionState>(3));
1772 value1.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
1773
1774 AccessTokenID tokenId = 123; // 123 is random input
1775 std::vector<GenericValues> permStateRes1;
1776 permStateRes1.emplace_back(value1);
1777
1778 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::RestorePermissionPolicy(tokenId,
1779 permStateRes1); // ret != RET_SUCCESS
1780
1781 ASSERT_EQ(tokenId, policySet->tokenId_);
1782
1783 GenericValues value2;
1784 value2.Put(TokenFiledConst::FIELD_TOKEN_ID, 123); // 123 is random input
1785 value2.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, true);
1786 value2.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
1787 value2.Put(TokenFiledConst::FIELD_DEVICE_ID, "dev-002");
1788 value2.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_DENIED);
1789 value2.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
1790 GenericValues value3;
1791 value3.Put(TokenFiledConst::FIELD_TOKEN_ID, 123); // 123 is random input
1792 value3.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, true);
1793 value3.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
1794 value3.Put(TokenFiledConst::FIELD_DEVICE_ID, "dev-003");
1795 value3.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_DENIED);
1796 value3.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
1797
1798 std::vector<GenericValues> permStateRes2;
1799 permStateRes2.emplace_back(value2);
1800 permStateRes2.emplace_back(value3);
1801
1802 std::shared_ptr<PermissionPolicySet> policySet2 = PermissionPolicySet::RestorePermissionPolicy(tokenId,
1803 permStateRes2); // state.permissionName == iter->permissionName
1804 ASSERT_EQ(static_cast<uint32_t>(2), policySet2->permStateList_[0].resDeviceID.size());
1805 }
1806
1807 /**
1808 * @tc.name: VerifyPermissionStatus001
1809 * @tc.desc: PermissionPolicySet::VerifyPermissionStatus function test
1810 * @tc.type: FUNC
1811 * @tc.require:
1812 */
HWTEST_F(AccessTokenInfoManagerTest, VerifyPermissionStatus001, TestSize.Level1)1813 HWTEST_F(AccessTokenInfoManagerTest, VerifyPermissionStatus001, TestSize.Level1)
1814 {
1815 PermissionStateFull perm = {
1816 .permissionName = "ohos.permission.TEST",
1817 .isGeneral = false,
1818 .resDeviceID = {"dev-001", "dev-001"},
1819 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1820 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1821 };
1822
1823 AccessTokenID tokenId = 123; // 123 is random input
1824 std::vector<PermissionStateFull> permStateList;
1825 permStateList.emplace_back(perm);
1826
1827 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1828 permStateList);
1829
1830 // isGeneral is false
1831 ASSERT_EQ(PermissionState::PERMISSION_DENIED, policySet->VerifyPermissionStatus("ohos.permission.TEST"));
1832 }
1833
1834 /**
1835 * @tc.name: QueryPermissionFlag001
1836 * @tc.desc: PermissionPolicySet::QueryPermissionFlag function test
1837 * @tc.type: FUNC
1838 * @tc.require:
1839 */
HWTEST_F(AccessTokenInfoManagerTest, QueryPermissionFlag001, TestSize.Level1)1840 HWTEST_F(AccessTokenInfoManagerTest, QueryPermissionFlag001, TestSize.Level1)
1841 {
1842 PermissionDef def = {
1843 .permissionName = "ohos.permission.TEST",
1844 .bundleName = "QueryPermissionFlag001",
1845 .grantMode = 1,
1846 .availableLevel = APL_NORMAL,
1847 .provisionEnable = false,
1848 .distributedSceneEnable = false,
1849 .label = "label",
1850 .labelId = 1,
1851 .description = "description",
1852 .descriptionId = 1
1853 };
1854 PermissionStateFull perm = {
1855 .permissionName = "ohos.permission.TEST",
1856 .isGeneral = false,
1857 .resDeviceID = {"dev-001", "dev-001"},
1858 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1859 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1860 };
1861
1862 AccessTokenID tokenId = 0x280bc140; // 0x280bc140 is random native
1863 PermissionDefinitionCache::GetInstance().Insert(def, tokenId);
1864 std::vector<PermissionStateFull> permStateList;
1865 permStateList.emplace_back(perm);
1866
1867 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1868 permStateList);
1869
1870 // perm.permissionName != permissionName
1871 int flag = 0;
1872 ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, policySet->QueryPermissionFlag("ohos.permission.TEST1", flag));
1873 // isGeneral is false
1874 ASSERT_EQ(ERR_PARAM_INVALID, policySet->QueryPermissionFlag("ohos.permission.TEST", flag));
1875
1876 perm.isGeneral = true;
1877 std::shared_ptr<PermissionPolicySet> policySet1 = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1878 permStateList);
1879 // isGeneral is true
1880 ASSERT_EQ(ERR_PARAM_INVALID, policySet1->QueryPermissionFlag("ohos.permission.TEST", flag));
1881 }
1882
1883 /**
1884 * @tc.name: UpdatePermissionStatus001
1885 * @tc.desc: PermissionPolicySet::UpdatePermissionStatus function test
1886 * @tc.type: FUNC
1887 * @tc.require:
1888 */
HWTEST_F(AccessTokenInfoManagerTest, UpdatePermissionStatus001, TestSize.Level1)1889 HWTEST_F(AccessTokenInfoManagerTest, UpdatePermissionStatus001, TestSize.Level1)
1890 {
1891 PermissionStateFull perm = {
1892 .permissionName = "ohos.permission.CAMERA",
1893 .isGeneral = false,
1894 .resDeviceID = {"dev-001", "dev-001"},
1895 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1896 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1897 };
1898
1899 AccessTokenID tokenId = 789; // 789 is random input
1900 std::vector<PermissionStateFull> permStateList;
1901 permStateList.emplace_back(perm);
1902
1903 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1904 permStateList);
1905
1906 // iter reach the end
1907 bool isGranted = false;
1908 uint32_t flag = PermissionFlag::PERMISSION_DEFAULT_FLAG;
1909 ASSERT_EQ(ERR_PARAM_INVALID, policySet->UpdatePermissionStatus("ohos.permission.TEST1",
1910 isGranted, flag));
1911
1912 // isGeneral is false
1913 ASSERT_EQ(RET_SUCCESS, policySet->UpdatePermissionStatus("ohos.permission.CAMERA",
1914 isGranted, flag));
1915 }
1916
1917 /**
1918 * @tc.name: ResetUserGrantPermissionStatus001
1919 * @tc.desc: PermissionPolicySet::ResetUserGrantPermissionStatus function test
1920 * @tc.type: FUNC
1921 * @tc.require:
1922 */
HWTEST_F(AccessTokenInfoManagerTest, ResetUserGrantPermissionStatus001, TestSize.Level1)1923 HWTEST_F(AccessTokenInfoManagerTest, ResetUserGrantPermissionStatus001, TestSize.Level1)
1924 {
1925 PermissionStateFull perm = {
1926 .permissionName = "ohos.permission.TEST",
1927 .isGeneral = false,
1928 .resDeviceID = {"dev-001", "dev-001"},
1929 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1930 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1931 };
1932
1933 AccessTokenID tokenId = 1011; // 1011 is random input
1934 std::vector<PermissionStateFull> permStateList;
1935 permStateList.emplace_back(perm);
1936
1937 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1938 permStateList);
1939
1940 ASSERT_EQ(tokenId, policySet->tokenId_);
1941
1942 // isGeneral is false
1943 policySet->ResetUserGrantPermissionStatus();
1944 }
1945
1946 /**
1947 * @tc.name: PermStateFullToString001
1948 * @tc.desc: PermissionPolicySet::PermStateFullToString function test
1949 * @tc.type: FUNC
1950 * @tc.require:
1951 */
HWTEST_F(AccessTokenInfoManagerTest, PermStateFullToString001, TestSize.Level1)1952 HWTEST_F(AccessTokenInfoManagerTest, PermStateFullToString001, TestSize.Level1)
1953 {
1954 AccessTokenID tokenId = 123; // 123 is random input
1955 std::vector<PermissionStateFull> permStateList;
1956 permStateList.emplace_back(g_permState);
1957
1958 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1959 permStateList);
1960
1961 ASSERT_EQ(tokenId, policySet->tokenId_);
1962
1963 std::string info;
1964 // iter != end - 1
1965 policySet->PermStateFullToString(g_permState, info);
1966 }
1967
1968 #ifdef TOKEN_SYNC_ENABLE
1969 /**
1970 * @tc.name: MapRemoteDeviceTokenToLocal001
1971 * @tc.desc: AccessTokenRemoteTokenManager::MapRemoteDeviceTokenToLocal function test
1972 * @tc.type: FUNC
1973 * @tc.require:
1974 */
HWTEST_F(AccessTokenInfoManagerTest, MapRemoteDeviceTokenToLocal001, TestSize.Level1)1975 HWTEST_F(AccessTokenInfoManagerTest, MapRemoteDeviceTokenToLocal001, TestSize.Level1)
1976 {
1977 std::map<std::string, AccessTokenRemoteDevice> remoteDeviceMap;
1978 remoteDeviceMap = AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_; // backup
1979 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.clear();
1980
1981 std::string deviceID;
1982 AccessTokenID remoteID = 0;
1983
1984 // input invalid
1985 ASSERT_EQ(static_cast<AccessTokenID>(0),
1986 AccessTokenRemoteTokenManager::GetInstance().MapRemoteDeviceTokenToLocal(deviceID, remoteID));
1987
1988 remoteID = 940572671; // 940572671 is max butt tokenId: 001 11 0 000000 11111111111111111111
1989 deviceID = "dev-001";
1990
1991 // tokeType invalid
1992 ASSERT_EQ(static_cast<AccessTokenID>(0),
1993 AccessTokenRemoteTokenManager::GetInstance().MapRemoteDeviceTokenToLocal(deviceID, remoteID));
1994
1995 remoteID = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111, no need to register
1996 std::map<AccessTokenID, AccessTokenID> MappingTokenIDPairMap;
1997 MappingTokenIDPairMap[537919487] = 456; // 456 is random input
1998 AccessTokenRemoteDevice device = {
1999 .deviceID_ = "dev-001",
2000 .MappingTokenIDPairMap_ = MappingTokenIDPairMap
2001 };
2002 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_["dev-001"] = device;
2003
2004 // count(remoteID) > 0
2005 ASSERT_EQ(static_cast<AccessTokenID>(456),
2006 AccessTokenRemoteTokenManager::GetInstance().MapRemoteDeviceTokenToLocal(deviceID, remoteID));
2007
2008 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_ = remoteDeviceMap; // recovery
2009 }
2010
2011 /**
2012 * @tc.name: GetDeviceAllRemoteTokenID001
2013 * @tc.desc: AccessTokenRemoteTokenManager::GetDeviceAllRemoteTokenID function test
2014 * @tc.type: FUNC
2015 * @tc.require:
2016 */
HWTEST_F(AccessTokenInfoManagerTest, GetDeviceAllRemoteTokenID001, TestSize.Level1)2017 HWTEST_F(AccessTokenInfoManagerTest, GetDeviceAllRemoteTokenID001, TestSize.Level1)
2018 {
2019 std::string deviceID;
2020 std::vector<AccessTokenID> remoteIDs;
2021
2022 // deviceID invalid
2023 ASSERT_EQ(ERR_PARAM_INVALID,
2024 AccessTokenRemoteTokenManager::GetInstance().GetDeviceAllRemoteTokenID(deviceID, remoteIDs));
2025 }
2026
2027 /**
2028 * @tc.name: RemoveDeviceMappingTokenID001
2029 * @tc.desc: AccessTokenRemoteTokenManager::RemoveDeviceMappingTokenID function test
2030 * @tc.type: FUNC
2031 * @tc.require:
2032 */
HWTEST_F(AccessTokenInfoManagerTest, RemoveDeviceMappingTokenID001, TestSize.Level1)2033 HWTEST_F(AccessTokenInfoManagerTest, RemoveDeviceMappingTokenID001, TestSize.Level1)
2034 {
2035 std::map<std::string, AccessTokenRemoteDevice> remoteDeviceMap;
2036 remoteDeviceMap = AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_; // backup
2037 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.clear();
2038
2039 std::string deviceID;
2040 AccessTokenID remoteID = 0;
2041
2042 // input invalid
2043 ASSERT_NE(RET_SUCCESS,
2044 AccessTokenRemoteTokenManager::GetInstance().RemoveDeviceMappingTokenID(deviceID, remoteID));
2045
2046 deviceID = "dev-001";
2047 remoteID = 123; // 123 is random input
2048
2049 // count < 1
2050 ASSERT_NE(RET_SUCCESS,
2051 AccessTokenRemoteTokenManager::GetInstance().RemoveDeviceMappingTokenID(deviceID, remoteID));
2052
2053 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_ = remoteDeviceMap; // recovery
2054 }
2055
2056 /**
2057 * @tc.name: AddHapTokenObservation001
2058 * @tc.desc: TokenModifyNotifier::AddHapTokenObservation function test
2059 * @tc.type: FUNC
2060 * @tc.require:
2061 */
HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenObservation001, TestSize.Level1)2062 HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenObservation001, TestSize.Level1)
2063 {
2064 std::set<AccessTokenID> observationSet = TokenModifyNotifier::GetInstance().observationSet_; // backup
2065 TokenModifyNotifier::GetInstance().observationSet_.clear();
2066
2067 AccessTokenID tokenId = 123; // 123 is random input
2068
2069 TokenModifyNotifier::GetInstance().observationSet_.insert(tokenId);
2070 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().observationSet_.count(tokenId) > 0);
2071
2072 // count > 0
2073 TokenModifyNotifier::GetInstance().AddHapTokenObservation(tokenId);
2074 TokenModifyNotifier::GetInstance().NotifyTokenModify(tokenId);
2075
2076 TokenModifyNotifier::GetInstance().observationSet_ = observationSet; // recovery
2077 }
2078 #endif
2079
2080 /**
2081 * @tc.name: RestoreNativeTokenInfo001
2082 * @tc.desc: NativeTokenInfoInner::RestoreNativeTokenInfo function test
2083 * @tc.type: FUNC
2084 * @tc.require:
2085 */
HWTEST_F(AccessTokenInfoManagerTest, RestoreNativeTokenInfo001, TestSize.Level1)2086 HWTEST_F(AccessTokenInfoManagerTest, RestoreNativeTokenInfo001, TestSize.Level1)
2087 {
2088 std::shared_ptr<NativeTokenInfoInner> native = std::make_shared<NativeTokenInfoInner>();
2089 ASSERT_NE(nullptr, native);
2090
2091 std::string info;
2092 native->ToString(info); // permPolicySet_ is null
2093
2094 AccessTokenID tokenId = 0;
2095 std::string processName;
2096 int apl = static_cast<int>(ATokenAplEnum::APL_INVALID);
2097 int version = 10; // 10 is random input which only need not equal 1
2098 std::vector<std::string> dcap;
2099 std::vector<std::string> nativeAcls;
2100 std::vector<PermissionStateFull> permStateList;
2101 GenericValues inGenericValues;
2102 std::vector<GenericValues> permStateRes;
2103
2104 inGenericValues.Put(TokenFiledConst::FIELD_PROCESS_NAME, processName);
2105 // processName invalid
2106 ASSERT_NE(RET_SUCCESS, native->RestoreNativeTokenInfo(tokenId, inGenericValues, permStateRes));
2107 inGenericValues.Remove(TokenFiledConst::FIELD_PROCESS_NAME);
2108
2109 inGenericValues.Put(TokenFiledConst::FIELD_PROCESS_NAME, processName);
2110 inGenericValues.Put(TokenFiledConst::FIELD_APL, apl);
2111 // apl invalid
2112 ASSERT_NE(RET_SUCCESS, native->RestoreNativeTokenInfo(tokenId, inGenericValues, permStateRes));
2113 inGenericValues.Remove(TokenFiledConst::FIELD_APL);
2114
2115 apl = static_cast<int>(ATokenAplEnum::APL_NORMAL);
2116 inGenericValues.Put(TokenFiledConst::FIELD_APL, apl);
2117 inGenericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, version);
2118 // version invalid
2119 ASSERT_NE(RET_SUCCESS, native->RestoreNativeTokenInfo(tokenId, inGenericValues, permStateRes));
2120 }
2121
2122 /**
2123 * @tc.name: RestoreHapTokenInfo001
2124 * @tc.desc: HapTokenInfoInner::RestoreHapTokenInfo function test
2125 * @tc.type: FUNC
2126 * @tc.require:
2127 */
HWTEST_F(AccessTokenInfoManagerTest, RestoreHapTokenInfo001, TestSize.Level1)2128 HWTEST_F(AccessTokenInfoManagerTest, RestoreHapTokenInfo001, TestSize.Level1)
2129 {
2130 std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>();
2131 ASSERT_NE(nullptr, hap);
2132
2133 AccessTokenID tokenId = 0;
2134 GenericValues tokenValue;
2135 std::vector<GenericValues> permStateRes;
2136 std::string bundleName;
2137 std::string appIDDesc;
2138 std::string deviceID;
2139 int aplNum = static_cast<int>(ATokenAplEnum::APL_INVALID);
2140 int version = 10; // 10 is random input which only need not equal 1
2141 HapPolicyParams policy;
2142 UpdateHapInfoParams hapInfo;
2143 hapInfo.apiVersion = DEFAULT_API_VERSION;
2144 hapInfo.isSystemApp = false;
2145 hap->Update(hapInfo, policy.permStateList, policy.apl); // permPolicySet_ is null
2146
2147 std::string info;
2148 hap->ToString(info); // permPolicySet_ is null
2149
2150 std::vector<GenericValues> hapInfoValues;
2151 std::vector<GenericValues> permStateValues;
2152 hap->StoreHapInfo(hapInfoValues);
2153 hap->StorePermissionPolicy(permStateValues); // permPolicySet_ is null
2154
2155
2156 tokenValue.Put(TokenFiledConst::FIELD_BUNDLE_NAME, bundleName);
2157 // bundleName invalid
2158 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2159 tokenValue.Remove(TokenFiledConst::FIELD_BUNDLE_NAME);
2160
2161 bundleName = "com.ohos.permissionmanger";
2162 tokenValue.Put(TokenFiledConst::FIELD_BUNDLE_NAME, bundleName);
2163 tokenValue.Put(TokenFiledConst::FIELD_APP_ID, appIDDesc);
2164 // appID invalid
2165 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2166 tokenValue.Remove(TokenFiledConst::FIELD_APP_ID);
2167
2168 appIDDesc = "what's this";
2169 tokenValue.Put(TokenFiledConst::FIELD_APP_ID, appIDDesc);
2170 tokenValue.Put(TokenFiledConst::FIELD_DEVICE_ID, deviceID);
2171 // deviceID invalid
2172 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2173 tokenValue.Remove(TokenFiledConst::FIELD_DEVICE_ID);
2174
2175 deviceID = "dev-001";
2176 tokenValue.Put(TokenFiledConst::FIELD_DEVICE_ID, deviceID);
2177 tokenValue.Put(TokenFiledConst::FIELD_APL, aplNum);
2178 // apl invalid
2179 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2180
2181 aplNum = static_cast<int>(ATokenAplEnum::APL_NORMAL);
2182 tokenValue.Put(TokenFiledConst::FIELD_APL, aplNum);
2183 tokenValue.Put(TokenFiledConst::FIELD_TOKEN_VERSION, version);
2184 // version invalid
2185 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2186 }
2187
2188 /**
2189 * @tc.name: RegisterTokenId001
2190 * @tc.desc: AccessTokenIDManager::RegisterTokenId function test
2191 * @tc.type: FUNC
2192 * @tc.require:
2193 */
HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenId001, TestSize.Level1)2194 HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenId001, TestSize.Level1)
2195 {
2196 // 1477443583 is max abnormal butt tokenId which version is 2: 010 11 0 000000 11111111111111111111
2197 AccessTokenID tokenId = 1477443583;
2198 ATokenTypeEnum type = ATokenTypeEnum::TOKEN_HAP;
2199
2200 // version != 1 + type dismatch
2201 ASSERT_NE(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, type));
2202
2203 AccessTokenIDEx tokenIdEx = {0};
2204 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
2205 g_infoManagerTestPolicyPrams1, tokenIdEx));
2206
2207 // register repeat
2208 ASSERT_NE(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(
2209 tokenIdEx.tokenIdExStruct.tokenID, type));
2210 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID));
2211 }
2212
2213 /**
2214 * @tc.name: ClearAllSecCompGrantedPerm001
2215 * @tc.desc: ClearAllSecCompGrantedPerm function test
2216 * @tc.type: FUNC
2217 * @tc.require:
2218 */
HWTEST_F(AccessTokenInfoManagerTest, ClearAllSecCompGrantedPerm001, TestSize.Level1)2219 HWTEST_F(AccessTokenInfoManagerTest, ClearAllSecCompGrantedPerm001, TestSize.Level1)
2220 {
2221 AccessTokenIDEx tokenIdEx = {0};
2222 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
2223 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
2224 ASSERT_EQ(RET_SUCCESS, ret);
2225 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2226
2227 ASSERT_EQ(PERMISSION_DENIED,
2228 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenId, "ohos.permission.LOCATION"));
2229 PermissionManager::GetInstance().GrantPermission(tokenId, "ohos.permission.LOCATION", PERMISSION_COMPONENT_SET);
2230 ASSERT_EQ(PERMISSION_GRANTED,
2231 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenId, "ohos.permission.LOCATION"));
2232
2233 std::string deviceId;
2234 atManagerService_->OnRemoveSystemAbility(SECURITY_COMPONENT_SERVICE_ID, deviceId);
2235 ASSERT_EQ(PERMISSION_DENIED,
2236 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenId, "ohos.permission.LOCATION"));
2237
2238 // delete test token
2239 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
2240 }
2241
2242 /**
2243 * @tc.name: ClearAllSecCompGrantedPerm002
2244 * @tc.desc: PermissionManager::ClearAllSecCompGrantedPerm function test
2245 * @tc.type: FUNC
2246 * @tc.require:
2247 */
HWTEST_F(AccessTokenInfoManagerTest, ClearAllSecCompGrantedPerm002, TestSize.Level1)2248 HWTEST_F(AccessTokenInfoManagerTest, ClearAllSecCompGrantedPerm002, TestSize.Level1)
2249 {
2250 AccessTokenID tokenId = 123; // 123 is random input
2251 std::vector<AccessTokenID> idList;
2252 idList.emplace_back(tokenId);
2253 PermissionManager::GetInstance().ClearAllSecCompGrantedPerm(idList); // permPolicySet is null
2254 auto tokenInfoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
2255 ASSERT_EQ(tokenInfoPtr, nullptr);
2256 }
2257
2258 /**
2259 * @tc.name: SetPermDialogCap001
2260 * @tc.desc: SetPermDialogCap with HapUniqueKey not exist
2261 * @tc.type: FUNC
2262 * @tc.require:
2263 */
HWTEST_F(AccessTokenInfoManagerTest, SetPermDialogCap001, TestSize.Level1)2264 HWTEST_F(AccessTokenInfoManagerTest, SetPermDialogCap001, TestSize.Level1)
2265 {
2266 AccessTokenID tokenId = 123; // 123: invalid tokenid
2267 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true));
2268 }
2269
2270 /**
2271 * @tc.name: SetPermDialogCap002
2272 * @tc.desc: SetPermDialogCap with abnormal branch
2273 * @tc.type: FUNC
2274 * @tc.require:
2275 */
HWTEST_F(AccessTokenInfoManagerTest, SetPermDialogCap002, TestSize.Level1)2276 HWTEST_F(AccessTokenInfoManagerTest, SetPermDialogCap002, TestSize.Level1)
2277 {
2278 AccessTokenIDEx tokenIdEx = {0};
2279 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
2280 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
2281 ASSERT_EQ(RET_SUCCESS, ret);
2282 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2283
2284 // SetPermDialogCap successfull
2285 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true));
2286 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2287 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, false));
2288 ASSERT_EQ(false, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2289
2290 std::shared_ptr<HapTokenInfoInner> back = AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId];
2291
2292 // tokeninfo of hapTokenInfoMap_ is nullptr, return true(forbid)
2293 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = nullptr;
2294 ASSERT_EQ(ERR_TOKENID_NOT_EXIST,
2295 AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true)); // info is null
2296 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2297
2298 // token is not found in hapTokenInfoMap_, return true(forbid)
2299 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
2300 ASSERT_EQ(ERR_TOKENID_NOT_EXIST,
2301 AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true)); // info is null
2302 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2303 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = back;
2304
2305 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
2306 }
2307
2308 /**
2309 * @tc.name: GetPermDialogCap001
2310 * @tc.desc: GetPermDialogCap with abnormal branch
2311 * @tc.type: FUNC
2312 * @tc.require:
2313 */
HWTEST_F(AccessTokenInfoManagerTest, GetPermDialogCap001, TestSize.Level1)2314 HWTEST_F(AccessTokenInfoManagerTest, GetPermDialogCap001, TestSize.Level1)
2315 {
2316 // invalid token
2317 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(INVALID_TOKENID));
2318
2319 // nonexist token
2320 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(123)); // 123: tokenid
2321
2322 // tokeninfo is nullptr
2323 HapBaseInfo baseInfo = {
2324 .userID = g_infoManagerTestInfoParms.userID,
2325 .bundleName = g_infoManagerTestInfoParms.bundleName,
2326 .instIndex = g_infoManagerTestInfoParms.instIndex,
2327 };
2328 AccessTokenIDEx tokenIdEx = {0};
2329 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
2330 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
2331 ASSERT_EQ(RET_SUCCESS, ret);
2332 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2333 std::shared_ptr<HapTokenInfoInner> back = AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId];
2334 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = nullptr;
2335 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(123)); // 123: tokenid
2336
2337 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = back;
2338 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
2339 }
2340
2341 /**
2342 * @tc.name: AllocHapToken001
2343 * @tc.desc: alloc hap create haptokeninfo failed.
2344 * @tc.type: FUNC
2345 * @tc.require:
2346 */
HWTEST_F(AccessTokenInfoManagerTest, AllocHapToken001, TestSize.Level1)2347 HWTEST_F(AccessTokenInfoManagerTest, AllocHapToken001, TestSize.Level1)
2348 {
2349 HapInfoParcel hapinfoParcel;
2350 hapinfoParcel.hapInfoParameter = {
2351 .userID = -1,
2352 .bundleName = "accesstoken_test",
2353 .instIndex = 0,
2354 .appIDDesc = "testtesttesttest",
2355 .apiVersion = DEFAULT_API_VERSION,
2356 .isSystemApp = false,
2357 };
2358 HapPolicyParcel hapPolicyParcel;
2359 hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
2360 hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
2361
2362 AccessTokenIDEx tokenIDEx = atManagerService_->AllocHapToken(hapinfoParcel, hapPolicyParcel);
2363 ASSERT_EQ(INVALID_TOKENID, tokenIDEx.tokenIDEx);
2364 }
2365
2366 /**
2367 * @tc.name: OnStart001
2368 * @tc.desc: service is running.
2369 * @tc.type: FUNC
2370 * @tc.require:
2371 */
HWTEST_F(AccessTokenInfoManagerTest, OnStart001, TestSize.Level1)2372 HWTEST_F(AccessTokenInfoManagerTest, OnStart001, TestSize.Level1)
2373 {
2374 ServiceRunningState state = atManagerService_->state_;
2375 atManagerService_->state_ = ServiceRunningState::STATE_RUNNING;
2376 atManagerService_->OnStart();
2377 ASSERT_EQ(ServiceRunningState::STATE_RUNNING, atManagerService_->state_);
2378 atManagerService_->state_ = state;
2379 }
2380
2381 /**
2382 * @tc.name: Dlopen001
2383 * @tc.desc: Open a not exist lib & not exist func
2384 * @tc.type: FUNC
2385 * @tc.require:
2386 */
HWTEST_F(AccessTokenInfoManagerTest, Dlopen001, TestSize.Level1)2387 HWTEST_F(AccessTokenInfoManagerTest, Dlopen001, TestSize.Level1)
2388 {
2389 LibraryLoader loader1("libnotexist.z.so"); // is a not exist path
2390 EXPECT_EQ(nullptr, loader1.handle_);
2391
2392 LibraryLoader loader2("libaccesstoken_manager_service.z.so"); // is a exist lib without create func
2393 EXPECT_EQ(nullptr, loader2.instance_);
2394 EXPECT_NE(nullptr, loader2.handle_);
2395 }
2396
2397 #ifdef TOKEN_SYNC_ENABLE
2398 /**
2399 * @tc.name: Dlopen002
2400 * @tc.desc: Open a exist lib & exist func
2401 * @tc.type: FUNC
2402 * @tc.require:
2403 */
HWTEST_F(AccessTokenInfoManagerTest, Dlopen002, TestSize.Level1)2404 HWTEST_F(AccessTokenInfoManagerTest, Dlopen002, TestSize.Level1)
2405 {
2406 LibraryLoader loader(TOKEN_SYNC_LIBPATH);
2407 TokenSyncKitInterface* tokenSyncKit = loader.GetObject<TokenSyncKitInterface>();
2408 EXPECT_NE(nullptr, loader.handle_);
2409 EXPECT_NE(nullptr, tokenSyncKit);
2410 }
2411 #endif
2412
2413 /**
2414 * @tc.name: OnRemoteRequest001
2415 * @tc.desc: Test OnRemoteRequest
2416 * @tc.type: FUNC
2417 * @tc.require:
2418 */
HWTEST_F(AccessTokenInfoManagerTest, OnRemoteRequest001, TestSize.Level1)2419 HWTEST_F(AccessTokenInfoManagerTest, OnRemoteRequest001, TestSize.Level1)
2420 {
2421 uint32_t code = 0;
2422 MessageParcel data;
2423 MessageParcel reply;
2424 MessageOption option;
2425 data.WriteInterfaceToken(u"this is a test interface");
2426 EXPECT_EQ(ERROR_IPC_REQUEST_FAIL, atManagerService_->OnRemoteRequest(code, data, reply, option));
2427
2428 std::map<uint32_t, AccessTokenManagerStub::RequestFuncType> oldMap = atManagerService_->requestFuncMap_;
2429 atManagerService_->requestFuncMap_.clear();
2430 atManagerService_->requestFuncMap_[1] = nullptr;
2431
2432 data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor());
2433 EXPECT_NE(NO_ERROR, atManagerService_->OnRemoteRequest(code, data, reply, option));
2434
2435 data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor());
2436 EXPECT_NE(NO_ERROR, atManagerService_->OnRemoteRequest(1, data, reply, option));
2437
2438 atManagerService_->requestFuncMap_ = oldMap;
2439 }
2440
2441 /**
2442 * @tc.name: VerifyNativeAccessToken001
2443 * @tc.desc: AccessTokenInfoManagerTest::VerifyNativeAccessToken function test
2444 * @tc.type: FUNC
2445 * @tc.require:
2446 */
HWTEST_F(AccessTokenInfoManagerTest, VerifyNativeAccessToken001, TestSize.Level1)2447 HWTEST_F(AccessTokenInfoManagerTest, VerifyNativeAccessToken001, TestSize.Level1)
2448 {
2449 AccessTokenID tokenId = 0x280bc142; // 0x280bc142 is random input
2450 std::string permissionName = "ohos.permission.INVALID_AA";
2451
2452 PermissionManager::GetInstance().RemoveDefPermissions(tokenId); // tokenInfo is null
2453
2454 // tokenInfoPtr is null
2455 ASSERT_EQ(PermissionState::PERMISSION_DENIED,
2456 AccessTokenInfoManager::GetInstance().VerifyNativeAccessToken(tokenId, permissionName));
2457
2458 // backup
2459 PermissionDefinitionCache::GetInstance().permissionDefinitionMap_.clear();
2460 PermissionDefinitionCache::GetInstance().hasHapPermissionDefinition_ = false;
2461
2462 // apl default normal, remote default false
2463 std::shared_ptr<NativeTokenInfoInner> native = std::make_shared<NativeTokenInfoInner>();
2464 ASSERT_NE(nullptr, native);
2465
2466 ASSERT_EQ(PermissionDefinitionCache::GetInstance().IsHapPermissionDefEmpty(), true);
2467 native->tokenInfoBasic_.apl = ATokenAplEnum::APL_SYSTEM_BASIC;
2468 native->tokenInfoBasic_.tokenID = tokenId;
2469 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_NATIVE));
2470 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(native));
2471
2472 // permission definition set has not been installed + apl >= APL_SYSTEM_BASIC
2473 ASSERT_EQ(PermissionState::PERMISSION_GRANTED,
2474 AccessTokenInfoManager::GetInstance().VerifyNativeAccessToken(tokenId, permissionName));
2475 PermissionDefinitionCache::GetInstance().permissionDefinitionMap_ = g_permissionDefinitionMap; // recovery
2476 PermissionDefinitionCache::GetInstance().hasHapPermissionDefinition_ = g_hasHapPermissionDefinition;
2477
2478 // not remote + no definition
2479 ASSERT_EQ(PermissionState::PERMISSION_DENIED,
2480 AccessTokenInfoManager::GetInstance().VerifyNativeAccessToken(tokenId, permissionName));
2481
2482 permissionName = "ohos.permission.CAMERA";
2483 // permPolicySet is null
2484 ASSERT_EQ(PermissionState::PERMISSION_DENIED,
2485 AccessTokenInfoManager::GetInstance().VerifyNativeAccessToken(tokenId, permissionName));
2486
2487 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId));
2488 }
2489
2490 /**
2491 * @tc.name: VerifyAccessToken001
2492 * @tc.desc: AccessTokenInfoManagerTest::VerifyAccessToken function test
2493 * @tc.type: FUNC
2494 * @tc.require:
2495 */
HWTEST_F(AccessTokenInfoManagerTest, VerifyAccessToken001, TestSize.Level1)2496 HWTEST_F(AccessTokenInfoManagerTest, VerifyAccessToken001, TestSize.Level1)
2497 {
2498 AccessTokenID tokenId = 0;
2499 std::string permissionName;
2500 // tokenID invalid
2501 ASSERT_EQ(PERMISSION_DENIED, AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenId, permissionName));
2502
2503 tokenId = 940572671; // 940572671 is max butt tokenId: 001 11 0 000000 11111111111111111111
2504 // permissionName invalid
2505 ASSERT_EQ(PERMISSION_DENIED, AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenId, permissionName));
2506
2507 // tokenID invalid
2508 permissionName = "ohos.permission.CAMERA";
2509 ASSERT_EQ(PERMISSION_DENIED, AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenId, permissionName));
2510 }
2511 } // namespace AccessToken
2512 } // namespace Security
2513 } // namespace OHOS
2514