1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdint>
17 #include <gtest/gtest.h>
18
19 #include "access_token.h"
20 #include "accesstoken_kit.h"
21 #include "camera_manager_adapter.h"
22 #include "constant.h"
23 #include "data_translator.h"
24 #include "permission_record.h"
25 #define private public
26 #include "active_status_callback_manager.h"
27 #include "permission_record_manager.h"
28 #include "permission_used_record_db.h"
29 #undef private
30 #include "perm_active_status_change_callback_stub.h"
31 #include "privacy_error.h"
32 #include "privacy_field_const.h"
33 #include "privacy_kit.h"
34 #include "privacy_test_common.h"
35 #include "state_change_callback.h"
36 #include "time_util.h"
37 #include "token_setproc.h"
38 #include "on_permission_used_record_callback_stub.h"
39
40 using namespace testing::ext;
41
42 namespace OHOS {
43 namespace Security {
44 namespace AccessToken {
45 namespace {
46 static int32_t PID = -1;
47 static constexpr int32_t CALLER_PID = 10;
48 static AccessTokenID g_selfTokenId = 0;
49 static AccessTokenID g_nativeToken = 0;
50 static constexpr int32_t MAX_DETAIL_NUM = 500;
51 static constexpr int64_t ONE_SECOND = 1000;
52 static constexpr int64_t TWO_SECOND = 2000;
53 static constexpr int64_t THREE_SECOND = 3000;
54 static constexpr int32_t PERMISSION_USED_TYPE_VALUE = 1;
55 static constexpr int32_t PERMISSION_USED_TYPE_WITH_PICKER_TYPE_VALUE = 3;
56 static constexpr uint32_t RANDOM_TOKENID = 123;
57 static constexpr int32_t TEST_USER_ID_11 = 11;
58 static constexpr int32_t INVALID_CODE = 9999;
59 static PermissionStateFull g_testState1 = {
60 .permissionName = "ohos.permission.CAMERA",
61 .isGeneral = true,
62 .resDeviceID = {"local"},
63 .grantStatus = {PermissionState::PERMISSION_GRANTED},
64 .grantFlags = {1}
65 };
66
67 static PermissionStateFull g_testState2 = {
68 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
69 .isGeneral = true,
70 .resDeviceID = {"local"},
71 .grantStatus = {PermissionState::PERMISSION_GRANTED},
72 .grantFlags = {1}
73 };
74
75 static HapPolicyParams g_PolicyPrams1 = {
76 .apl = APL_NORMAL,
77 .domain = "test.domain.A",
78 .permList = {},
79 .permStateList = {g_testState1, g_testState2}
80 };
81
82 static HapInfoParams g_InfoParms1 = {
83 .userID = 1,
84 .bundleName = "ohos.privacy_test.bundleA",
85 .instIndex = 0,
86 .appIDDesc = "privacy_test.bundleA"
87 };
88
89 static HapPolicyParams g_PolicyPrams2 = {
90 .apl = APL_NORMAL,
91 .domain = "test.domain.B",
92 .permList = {},
93 .permStateList = {g_testState1}
94 };
95
96 static HapInfoParams g_InfoParms2 = {
97 .userID = 1,
98 .bundleName = "ohos.privacy_test.bundleB",
99 .instIndex = 0,
100 .appIDDesc = "privacy_test.bundleB"
101 };
102 }
103 class PermissionRecordManagerTest : public testing::Test {
104 public:
105 static void SetUpTestCase();
106
107 static void TearDownTestCase();
108
109 void SetUp();
110
111 void TearDown();
112 };
113
SetUpTestCase()114 void PermissionRecordManagerTest::SetUpTestCase()
115 {
116 g_selfTokenId = GetSelfTokenID();
117 PrivacyTestCommon::SetTestEvironment(g_selfTokenId);
118
119 g_nativeToken = PrivacyTestCommon::GetNativeTokenIdFromProcess("privacy_service");
120 }
121
TearDownTestCase()122 void PermissionRecordManagerTest::TearDownTestCase()
123 {
124 PrivacyTestCommon::ResetTestEvironment();
125 }
126
SetUp()127 void PermissionRecordManagerTest::SetUp()
128 {
129 PermissionRecordManager::GetInstance().Register();
130
131 PrivacyTestCommon::AllocTestHapToken(g_InfoParms1, g_PolicyPrams1);
132 PrivacyTestCommon::AllocTestHapToken(g_InfoParms2, g_PolicyPrams2);
133 }
134
TearDown()135 void PermissionRecordManagerTest::TearDown()
136 {
137 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
138 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
139 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
140 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
141 g_InfoParms2.userID, g_InfoParms2.bundleName, g_InfoParms2.instIndex);
142 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
143 }
144
145 class PermissionRecordManagerCoverTestCb1 : public StateCustomizedCbk {
146 public:
PermissionRecordManagerCoverTestCb1()147 PermissionRecordManagerCoverTestCb1()
148 {}
149
~PermissionRecordManagerCoverTestCb1()150 ~PermissionRecordManagerCoverTestCb1()
151 {}
152
StateChangeNotify(AccessTokenID tokenId,bool isShow)153 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
154 {}
155
Stop()156 void Stop()
157 {}
158 };
159
160 class PermissionRecordManagerCoverTestCb2 : public IRemoteObject {
161 public:
PermissionRecordManagerCoverTestCb2()162 PermissionRecordManagerCoverTestCb2()
163 {}
164
~PermissionRecordManagerCoverTestCb2()165 ~PermissionRecordManagerCoverTestCb2()
166 {}
167 };
168
MakeInfo(AccessTokenID tokenId,int32_t pid,const std::string & permission,PermissionUsedType type=PermissionUsedType::NORMAL_TYPE)169 static PermissionUsedTypeInfo MakeInfo(AccessTokenID tokenId, int32_t pid, const std::string &permission,
170 PermissionUsedType type = PermissionUsedType::NORMAL_TYPE)
171 {
172 PermissionUsedTypeInfo info = {
173 .tokenId = tokenId,
174 .pid = pid,
175 .permissionName = permission,
176 .type = type
177 };
178 return info;
179 }
180
181 /*
182 * @tc.name: AppStatusListener001
183 * @tc.desc: register and startusing permissions then use NotifyAppStateChange
184 * @tc.type: FUNC
185 * @tc.require: issueI5SZHG
186 */
187 HWTEST_F(PermissionRecordManagerTest, AppStatusListener001, TestSize.Level4)
188 {
189 AccessTokenIDEx tokenIdEx1 = PrivacyTestCommon::GetHapTokenIdFromBundle(
190 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
191 AccessTokenID tokenId1 = tokenIdEx1.tokenIdExStruct.tokenID;
192 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId1);
193
194 AccessTokenIDEx tokenIdEx2 = PrivacyTestCommon::GetHapTokenIdFromBundle(
195 g_InfoParms2.userID, g_InfoParms2.bundleName, g_InfoParms2.instIndex);
196 AccessTokenID tokenId2 = tokenIdEx2.tokenIdExStruct.tokenID;
197 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId2);
198
199 ContinusPermissionRecord recordA1 = {
200 .tokenId = tokenId1,
201 .opCode = Constant::OP_CAMERA,
202 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
203 };
204
205 ContinusPermissionRecord recordA2 = {
206 .tokenId = tokenId1,
207 .opCode = Constant::OP_MICROPHONE,
208 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
209 };
210
211 ContinusPermissionRecord recordB1 = {
212 .tokenId = tokenId2,
213 .opCode = Constant::OP_CAMERA,
214 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
215 };
216
217 ContinusPermissionRecord recordB2 = {
218 .tokenId = tokenId2,
219 .opCode = Constant::OP_MICROPHONE,
220 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
221 };
222
223 PermissionRecordManager::GetInstance().startRecordList_.emplace(recordA1);
224 PermissionRecordManager::GetInstance().startRecordList_.emplace(recordA2);
225 PermissionRecordManager::GetInstance().startRecordList_.emplace(recordB1);
226 PermissionRecordManager::GetInstance().startRecordList_.emplace(recordB2);
227
228 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_FOREGROUND);
229 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_FOREGROUND);
230 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_FOREGROUND);
231 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_FOREGROUND);
232 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_BACKGROUND);
233 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_BACKGROUND);
234 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_BACKGROUND);
235 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_BACKGROUND);
236 }
237
238 /*
239 * @tc.name: FindRecordsToUpdateAndExecutedTest001
240 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
241 * @tc.type: FUNC
242 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
243 */
244 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest001, TestSize.Level4)
245 {
246 std::vector<std::string> reqPerm;
247 reqPerm.emplace_back("ohos.permission.CAMERA");
248 reqPerm.emplace_back("ohos.permission.MANAGE_CAMERA_CONFIG");
249 MockHapToken mock("FindRecordsToUpdateAndExecutedTest001", reqPerm, false);
250
251 AccessTokenID tokenId = GetSelfTokenID();
252 ASSERT_NE(INVALID_TOKENID, tokenId);
253
254 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
255 std::string permission = "ohos.permission.CAMERA";
256 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::CAMERA, false,
257 RANDOM_TOKENID);
258 PermissionRecordManager::GetInstance().AddRecordToStartList(MakeInfo(tokenId, PID, permission), status, CALLER_PID);
259 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
260 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, status);
261
262 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
263 tokenId, PID, permission, CALLER_PID));
264 }
265
266 /*
267 * @tc.name: FindRecordsToUpdateAndExecutedTest002
268 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
269 * @tc.type: FUNC
270 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
271 */
272 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest002, TestSize.Level4)
273 {
274 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
275 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
276 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
277 ASSERT_NE(INVALID_TOKENID, tokenId);
278 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
279 std::string permission = "ohos.permission.MICROPHONE";
280 PermissionRecordManager::GetInstance().AddRecordToStartList(MakeInfo(tokenId, PID, permission), status, CALLER_PID);
281 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
282 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, status);
283
284 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
285 tokenId, PID, permission, CALLER_PID));
286 }
287
288 /*
289 * @tc.name: FindRecordsToUpdateAndExecutedTest003
290 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
291 * @tc.type: FUNC
292 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
293 */
294 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest003, TestSize.Level4)
295 {
296 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
297 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
298 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
299 ASSERT_NE(INVALID_TOKENID, tokenId);
300 ActiveChangeType status = PERM_ACTIVE_IN_FOREGROUND;
301 std::string permission = "ohos.permission.CAMERA";
302 PermissionRecordManager::GetInstance().AddRecordToStartList(MakeInfo(tokenId, PID, permission), status, CALLER_PID);
303 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
304
305 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
306 tokenId, PID, permission, CALLER_PID));
307 }
308
309 /*
310 * @tc.name: FindRecordsToUpdateAndExecutedTest004
311 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
312 * @tc.type: FUNC
313 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
314 */
315 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest004, TestSize.Level4)
316 {
317 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
318 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
319 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
320 ASSERT_NE(INVALID_TOKENID, tokenId);
321 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
322 std::string permission = "ohos.permission.CAMERA";
323 PermissionRecordManager::GetInstance().AddRecordToStartList(MakeInfo(tokenId, PID, permission), status, CALLER_PID);
324 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
325
326 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
327 tokenId, PID, permission, CALLER_PID));
328 }
329
330 /*
331 * @tc.name: ExecuteCameraCallbackAsyncTest001
332 * @tc.desc: Verify the ExecuteCameraCallbackAsync abnormal branch function test with.
333 * @tc.type: FUNC
334 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
335 */
336 HWTEST_F(PermissionRecordManagerTest, ExecuteCameraCallbackAsyncTest001, TestSize.Level4)
337 {
338 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
339 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
340 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
341 ASSERT_NE(INVALID_TOKENID, tokenId);
342
343 auto callbackPtr = std::make_shared<PermissionRecordManagerCoverTestCb1>();
344 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
345 ASSERT_NE(nullptr, callbackPtr);
346 ASSERT_NE(nullptr, callbackWrap);
347 PermissionRecordManager::GetInstance().ExecuteCameraCallbackAsync(tokenId, PID);
348
349 PermissionRecordManager::GetInstance().ExecuteCameraCallbackAsync(tokenId, PID);
350 }
351
352 class PermActiveStatusChangeCallbackTest : public PermActiveStatusChangeCallbackStub {
353 public:
354 PermActiveStatusChangeCallbackTest() = default;
355 virtual ~PermActiveStatusChangeCallbackTest() = default;
356
357 void ActiveStatusChangeCallback(ActiveChangeResponse& result) override;
358 bool AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient>& deathRecipient) override;
359 };
360
ActiveStatusChangeCallback(ActiveChangeResponse & result)361 void PermActiveStatusChangeCallbackTest::ActiveStatusChangeCallback(ActiveChangeResponse& result)
362 {
363 }
364
AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient> & deathRecipient)365 bool PermActiveStatusChangeCallbackTest::AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient>& deathRecipient)
366 {
367 return true;
368 }
369
370 class PermissionRecordManagerCoverTestCb3 : public PermActiveStatusCustomizedCbk {
371 public:
PermissionRecordManagerCoverTestCb3(const std::vector<std::string> & permList)372 explicit PermissionRecordManagerCoverTestCb3(const std::vector<std::string> &permList)
373 : PermActiveStatusCustomizedCbk(permList)
374 {
375 GTEST_LOG_(INFO) << "PermissionRecordManagerCoverTestCb3 create";
376 }
377
~PermissionRecordManagerCoverTestCb3()378 ~PermissionRecordManagerCoverTestCb3()
379 {}
380
ActiveStatusChangeCallback(ActiveChangeResponse & result)381 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
382 {
383 type_ = result.type;
384 }
385
386 ActiveChangeType type_ = PERM_INACTIVE;
387 };
388
389 /*
390 * @tc.name: OnRemoteDied001
391 * @tc.desc: PermActiveStatusCallbackDeathRecipient::OnRemoteDied function test
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(PermissionRecordManagerTest, OnRemoteDied001, TestSize.Level4)
396 {
397 auto recipient = std::make_shared<PermActiveStatusCallbackDeathRecipient>();
398 ASSERT_NE(nullptr, recipient);
399
400 recipient->OnRemoteDied(nullptr); // remote is nullptr
401
402 // backup
403 std::vector<CallbackData> callbackDataList = ActiveStatusCallbackManager::GetInstance().callbackDataList_;
404 ActiveStatusCallbackManager::GetInstance().callbackDataList_.clear();
405
406 std::vector<std::string> permList;
407 sptr<IRemoteObject> callback;
408 permList.emplace_back("ohos.permission.CAMERA");
409 wptr<IRemoteObject> remote = new (std::nothrow) PermActiveStatusChangeCallbackTest();
410 callback = remote.promote();
411 ActiveStatusCallbackManager::GetInstance().AddCallback(GetSelfTokenID(), permList, callback);
412 ASSERT_EQ(static_cast<uint32_t>(1), ActiveStatusCallbackManager::GetInstance().callbackDataList_.size());
413 recipient->OnRemoteDied(remote); // remote is not nullptr
414 ASSERT_EQ(static_cast<uint32_t>(0), ActiveStatusCallbackManager::GetInstance().callbackDataList_.size());
415
416 // recovery
417 ActiveStatusCallbackManager::GetInstance().callbackDataList_ = callbackDataList;
418 }
419
420 /**
421 * @tc.name: OnApplicationStateChanged001
422 * @tc.desc: Test app state changed to APP_STATE_TERMINATED.
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(PermissionRecordManagerTest, OnApplicationStateChanged001, TestSize.Level4)
427 {
428 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
429 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
430 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
431 ASSERT_NE(INVALID_TOKENID, tokenId);
432
433 PrivacyAppStateObserver observer;
434 std::vector<std::string> permList = {"ohos.permission.READ_MEDIA"};
435
436 auto callbackPtr = std::make_shared<PermissionRecordManagerCoverTestCb3>(permList);
437 callbackPtr->type_ = PERM_ACTIVE_IN_FOREGROUND;
438
439 ASSERT_EQ(RET_SUCCESS, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
440 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(tokenId, "ohos.permission.READ_MEDIA"));
441 AppStateData appStateData;
442 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_TERMINATED);
443 appStateData.accessTokenId = tokenId;
444 observer.OnAppStopped(appStateData);
445
446 appStateData.state = INVALID_CODE;
447 observer.OnAppStopped(appStateData);
448
449 usleep(500000); // 500000us = 0.5s
450 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
451
452 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(tokenId, "ohos.permission.READ_MEDIA"));
453 }
454
455 /*
456 * @tc.name: RemoveCallback001
457 * @tc.desc: ActiveStatusCallbackManager::RemoveCallback function test
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(PermissionRecordManagerTest, RemoveCallback001, TestSize.Level4)
462 {
463 std::vector<std::string> permList;
464 sptr<IRemoteObject> callback;
465
466 // callback is null
467 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, ActiveStatusCallbackManager::GetInstance().RemoveCallback(nullptr));
468
469 // backup
470 std::vector<CallbackData> callbackDataList = ActiveStatusCallbackManager::GetInstance().callbackDataList_;
471 sptr<IRemoteObject::DeathRecipient> callbackDeathRecipient =
472 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_;
473 ActiveStatusCallbackManager::GetInstance().callbackDataList_.clear();
474 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_ = nullptr;
475
476 sptr<PermActiveStatusChangeCallbackTest> callback1 = new (std::nothrow) PermActiveStatusChangeCallbackTest();
477 ASSERT_NE(nullptr, callback1);
478 sptr<PermActiveStatusChangeCallbackTest> callback2 = new (std::nothrow) PermActiveStatusChangeCallbackTest();
479 ASSERT_NE(nullptr, callback2);
480 permList.emplace_back("ohos.permission.CAMERA");
481 callback = callback1->AsObject();
482 CallbackData data;
483 data.permList_ = permList;
484 data.callbackObject_ = callback;
485 ActiveStatusCallbackManager::GetInstance().callbackDataList_.emplace_back(data);
486 // callback != callbackObject_
487 ASSERT_EQ(RET_SUCCESS, ActiveStatusCallbackManager::GetInstance().RemoveCallback(callback2->AsObject()));
488
489 // callback == callbackObject_ + callbackDeathRecipient_ is null
490 ASSERT_EQ(RET_SUCCESS, ActiveStatusCallbackManager::GetInstance().RemoveCallback(callback));
491
492 // recovery
493 ActiveStatusCallbackManager::GetInstance().callbackDataList_ = callbackDataList;
494 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_ = callbackDeathRecipient;
495 }
496
497 /*
498 * @tc.name: UpdateRecords001
499 * @tc.desc: PermissionRecordManager::UpdateRecords function test
500 * @tc.type: FUNC
501 * @tc.require:
502 */
503 HWTEST_F(PermissionRecordManagerTest, UpdateRecords001, TestSize.Level4)
504 {
505 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
506 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
507 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
508 ASSERT_NE(INVALID_TOKENID, tokenId);
509
510 PermissionUsageFlag flag = FLAG_PERMISSION_USAGE_SUMMARY;
511 PermissionUsedRecord inBundleRecord;
512 PermissionUsedRecord outBundleRecord;
513
514 inBundleRecord.lastAccessTime = 1000;
515 outBundleRecord.lastAccessTime = 900;
516 // inBundleRecord.lastAccessTime > outBundleRecord.lastAccessTime && flag == 0
517 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
518
519 UsedRecordDetail detail;
520 detail.accessDuration = 10;
521 detail.status = PERM_ACTIVE_IN_FOREGROUND;
522 detail.timestamp = 10000;
523 flag = FLAG_PERMISSION_USAGE_DETAIL;
524 inBundleRecord.lastRejectTime = 1000;
525 inBundleRecord.accessRecords.emplace_back(detail);
526 inBundleRecord.rejectRecords.emplace_back(detail);
527 // flag != 0 && inBundleRecord.lastRejectTime > 0 && outBundleRecord.accessRecords.size() < 10
528 // && inBundleRecord.lastRejectTime > 0 && outBundleRecord.rejectRecords.size() < 10
529 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
530
531 std::vector<UsedRecordDetail> accessRecords(11, detail);
532 outBundleRecord.accessRecords = accessRecords;
533 outBundleRecord.rejectRecords = accessRecords;
534 // flag != 0 && inBundleRecord.lastRejectTime > 0 && outBundleRecord.accessRecords.size() >= 10
535 // && inBundleRecord.lastRejectTime > 0 && outBundleRecord.rejectRecords.size() >= 10
536 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
537
538 inBundleRecord.lastAccessTime = 0;
539 inBundleRecord.lastRejectTime = 0;
540 // flag != 0 && inBundleRecord.lastRejectTime <= 0 && outBundleRecord.accessRecords.size() >= 10
541 // && inBundleRecord.lastRejectTime <= 0 && outBundleRecord.rejectRecords.size() >= 10
542 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
543 }
544
545 /*
546 * @tc.name: RemoveRecordFromStartList001
547 * @tc.desc: PermissionRecordManager::RemoveRecordFromStartList function test
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 HWTEST_F(PermissionRecordManagerTest, RemoveRecordFromStartList001, TestSize.Level4)
552 {
553 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
554 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
555 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
556 ASSERT_NE(INVALID_TOKENID, tokenId);
557
558 std::string permission = "ohos.permission.READ_MEDIA";
559 ASSERT_EQ(Constant::SUCCESS,
560 PermissionRecordManager::GetInstance().StartUsingPermission(
561 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
562 // it->opcode == record.opcode && it->tokenId == record.tokenId
563 PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
564 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID);
565
566 ASSERT_EQ(Constant::SUCCESS,
567 PermissionRecordManager::GetInstance().StartUsingPermission(
568 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
569 // it->opcode == record.opcode && it->tokenId != record.tokenId
570 PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
571 RANDOM_TOKENID, PID, "ohos.permission.READ_MEDIA", CALLER_PID);
572
573 // it->opcode != record.opcode && it->tokenId != record.tokenId
574 PermissionRecordManager::GetInstance().RemoveRecordFromStartList(
575 tokenId, PID, "ohos.permission.MICROPHONE", CALLER_PID);
576
577 ASSERT_EQ(Constant::SUCCESS,
578 PermissionRecordManager::GetInstance().StopUsingPermission(
579 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID));
580 }
581
582 /*
583 * @tc.name: PermissionListFilter001
584 * @tc.desc: PermissionRecordManager::PermissionListFilter function test
585 * @tc.type: FUNC
586 * @tc.require:
587 */
588 HWTEST_F(PermissionRecordManagerTest, PermissionListFilter001, TestSize.Level4)
589 {
590 std::vector<std::string> listSrc;
591 std::vector<std::string> listRes;
592
593 listSrc.emplace_back("com.ohos.TEST");
594 // GetDefPermission != Constant::SUCCESS && listRes is empty && listSrc is not empty
595 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
596 PermissionRecordManager::GetInstance().PermissionListFilter(listSrc, listRes));
597
598 listRes.emplace_back("com.ohos.TEST");
599 // listRes is not empty
600 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().PermissionListFilter(listSrc, listRes));
601
602 listSrc.clear();
603 listRes.clear();
604 // listRes is empty && listSrc is empty
605 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().PermissionListFilter(listSrc, listRes));
606 }
607
608 /*
609 * @tc.name: Unregister001
610 * @tc.desc: PermissionRecordManager::Unregister function test
611 * @tc.type: FUNC
612 * @tc.require:
613 */
614 HWTEST_F(PermissionRecordManagerTest, Unregister001, TestSize.Level4)
615 {
616 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
617 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
618 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
619 ASSERT_NE(INVALID_TOKENID, tokenId);
620
621 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
622 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
623
624 PermissionRecordManager::GetInstance().Unregister();
625 PermissionRecordManager::GetInstance().Unregister();
626
627 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StopUsingPermission(
628 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID));
629 }
630
631 /*
632 * @tc.name: TranslationIntoPermissionRecord001
633 * @tc.desc: PermissionRecord::TranslationIntoPermissionRecord function test
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(PermissionRecordManagerTest, TranslationIntoPermissionRecord001, TestSize.Level4)
638 {
639 GenericValues values;
640 values.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(10086));
641 values.Put(PrivacyFiledConst::FIELD_OP_CODE, 0);
642 values.Put(PrivacyFiledConst::FIELD_STATUS, 0);
643 values.Put(PrivacyFiledConst::FIELD_TIMESTAMP, static_cast<int64_t>(20210109));
644 values.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, static_cast<int64_t>(1));
645 values.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 10);
646 values.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 100);
647 values.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
648 PermissionRecord record;
649 PermissionRecord::TranslationIntoPermissionRecord(values, record);
650 ASSERT_EQ(static_cast<int32_t>(10086), record.tokenId);
651 ASSERT_EQ(10, record.accessCount);
652 ASSERT_EQ(100, record.rejectCount);
653 ASSERT_EQ(static_cast<int64_t>(20210109), record.timestamp);
654 ASSERT_EQ(static_cast<int64_t>(1), record.accessDuration);
655 ASSERT_EQ(LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED, record.lockScreenStatus);
656 }
657
AddRecord(int32_t num,std::vector<GenericValues> & values)658 void AddRecord(int32_t num, std::vector<GenericValues>& values)
659 {
660 for (int32_t i = 0; i < num; i++) {
661 GenericValues value;
662 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, i);
663 value.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_LOCATION);
664 value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND);
665 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, i);
666 value.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, i);
667 value.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
668 value.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
669 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
670 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
671 values.emplace_back(value);
672 }
673
674 ASSERT_EQ(static_cast<size_t>(num), values.size());
675 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
676 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
677 sleep(1); // wait record store in database
678 }
679
680 /**
681 * @tc.name: GetRecords002
682 * @tc.desc: test query record return max count 500.
683 * @tc.type: FUNC
684 * @tc.require: issueI5P4IU
685 */
686 HWTEST_F(PermissionRecordManagerTest, GetRecords002, TestSize.Level4)
687 {
688 std::vector<GenericValues> values;
689 int32_t num = MAX_DETAIL_NUM + 1;
690 AddRecord(num, values);
691
692 PermissionUsedRequest request;
693 request.isRemote = false;
694 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_DETAIL;
695
696 std::set<int32_t> opCodeList;
697 GenericValues andConditionValues;
698 std::vector<GenericValues> findRecordsValues;
699 PermissionUsedRecordDb::GetInstance().FindByConditions(PermissionUsedRecordDb::DataType::PERMISSION_RECORD,
700 opCodeList, andConditionValues, findRecordsValues, MAX_DETAIL_NUM);
701 EXPECT_EQ(static_cast<size_t>(MAX_DETAIL_NUM), findRecordsValues.size());
702
703 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
704 for (const auto& value : values) {
705 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value));
706 }
707 }
708
GeneratePermissionRecord(AccessTokenID tokenID)709 static void GeneratePermissionRecord(AccessTokenID tokenID)
710 {
711 int64_t timestamp = AccessToken::TimeUtil::GetCurrentTimestamp();
712
713 std::vector<GenericValues> values;
714 GenericValues value;
715 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenID));
716 value.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_LOCATION);
717 value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND);
718 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp - THREE_SECOND);
719 value.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 1);
720 value.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
721 value.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
722 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
723 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
724 values.emplace_back(value); // background + unlock + normal
725
726 value.Remove(PrivacyFiledConst::FIELD_TIMESTAMP);
727 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp - TWO_SECOND);
728 value.Remove(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS);
729 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
730 values.emplace_back(value); // background + lock + normal
731
732 value.Remove(PrivacyFiledConst::FIELD_STATUS);
733 value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
734 value.Remove(PrivacyFiledConst::FIELD_TIMESTAMP);
735 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp - ONE_SECOND);
736 value.Remove(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS);
737 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
738 values.emplace_back(value); // foreground + unlock + normal
739
740 value.Remove(PrivacyFiledConst::FIELD_TIMESTAMP);
741 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp);
742 value.Remove(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS);
743 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
744 values.emplace_back(value); // foreground + lock + normal
745
746 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
747 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
748 sleep(1); // wait record store in database
749 }
750
751 /**
752 * @tc.name: GetRecords003
753 * @tc.desc: test query record flag 2 | 3 | 4 | 5
754 * @tc.type: FUNC
755 * @tc.require:
756 */
757 HWTEST_F(PermissionRecordManagerTest, GetRecords003, TestSize.Level4)
758 {
759 MockNativeToken mock("privacy_service");
760 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
761 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
762 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
763 ASSERT_NE(INVALID_TOKENID, tokenID);
764
765 GeneratePermissionRecord(tokenID);
766 PermissionRecordManager::GetInstance().SetDefaultConfigValue();
767
768 PermissionUsedRequest request;
769 request.tokenId = tokenID;
770 request.isRemote = false;
771 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
772
773 PermissionUsedResult result1;
774 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result1));
775 EXPECT_EQ(static_cast<size_t>(1), result1.bundleRecords.size());
776 EXPECT_EQ(static_cast<uint32_t>(tokenID), result1.bundleRecords[0].tokenId);
777 EXPECT_EQ(static_cast<size_t>(1), result1.bundleRecords[0].permissionRecords.size());
778 EXPECT_EQ(2, result1.bundleRecords[0].permissionRecords[0].accessCount);
779
780 PermissionUsedResult result2;
781 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_UNLOCKED;
782 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result2));
783 EXPECT_EQ(static_cast<size_t>(1), result2.bundleRecords.size());
784 EXPECT_EQ(static_cast<uint32_t>(tokenID), result2.bundleRecords[0].tokenId);
785 EXPECT_EQ(static_cast<size_t>(1), result2.bundleRecords[0].permissionRecords.size());
786 EXPECT_EQ(2, result2.bundleRecords[0].permissionRecords[0].accessCount);
787
788 PermissionUsedResult result3;
789 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_FOREGROUND;
790 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result3));
791 EXPECT_EQ(static_cast<size_t>(1), result3.bundleRecords.size());
792 EXPECT_EQ(static_cast<uint32_t>(tokenID), result3.bundleRecords[0].tokenId);
793 EXPECT_EQ(static_cast<size_t>(1), result3.bundleRecords[0].permissionRecords.size());
794 EXPECT_EQ(2, result3.bundleRecords[0].permissionRecords[0].accessCount);
795
796 PermissionUsedResult result4;
797 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_BACKGROUND;
798 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result4));
799 EXPECT_EQ(static_cast<size_t>(1), result4.bundleRecords.size());
800 EXPECT_EQ(static_cast<uint32_t>(tokenID), result4.bundleRecords[0].tokenId);
801 EXPECT_EQ(static_cast<size_t>(1), result4.bundleRecords[0].permissionRecords.size());
802 EXPECT_EQ(2, result4.bundleRecords[0].permissionRecords[0].accessCount);
803 }
804
805 /**
806 * @tc.name: GetRecords004
807 * @tc.desc: test query record from local dd failed
808 * @tc.type: FUNC
809 * @tc.require:
810 */
811 HWTEST_F(PermissionRecordManagerTest, GetRecords004, TestSize.Level4)
812 {
813 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
814 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
815 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
816 ASSERT_NE(INVALID_TOKENID, tokenID);
817
818 GeneratePermissionRecord(tokenID);
819 PermissionRecordManager::GetInstance().SetDefaultConfigValue();
820
821 PermissionUsedRequest request;
822 request.tokenId = tokenID;
823 request.isRemote = false;
824 request.beginTimeMillis = -1;
825
826 PermissionUsedResult result;
827 EXPECT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result));
828 }
829
830 /**
831 * @tc.name: GetRecords005
832 * @tc.desc: test ERR_PARAM_INVALID
833 * @tc.type: FUNC
834 * @tc.require:
835 */
836 HWTEST_F(PermissionRecordManagerTest, GetRecords005, TestSize.Level4)
837 {
838 PermissionRecordManager::GetInstance().UpdatePermRecImmediately();
839
840 AddPermParamInfo info;
841
842 PermissionRecord result;
843 EXPECT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().GetPermissionRecord(info, result));
844
845 PermissionRecordManager::GetInstance().ExecuteDeletePermissionRecordTask();
846 }
847
848 /**
849 * @tc.name: SetPermissionUsedRecordToggleStatus001
850 * @tc.desc: test ERR_PARAM_INVALID
851 * @tc.type: FUNC
852 * @tc.require:
853 */
854 HWTEST_F(PermissionRecordManagerTest, SetPermissionUsedRecordToggleStatus001, TestSize.Level4)
855 {
856 MockNativeToken mock("privacy_service");
857
858 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(0, false));
859 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(0, true));
860 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(0, true));
861
862 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
863 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
864 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
865 ASSERT_NE(INVALID_TOKENID, tokenID);
866
867 GeneratePermissionRecord(tokenID);
868
869 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(1, false));
870 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(1, true));
871 EXPECT_EQ(Constant::SUCCESS,
872 PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(105, false));
873 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(105, true));
874 }
875
876 /**
877 * @tc.name: GetPermissionUsedRecordToggleStatus001
878 * @tc.desc: test ERR_PARAM_INVALID
879 * @tc.type: FUNC
880 * @tc.require:
881 */
882 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedRecordToggleStatus001, TestSize.Level4)
883 {
884 bool res = true;
885 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecordToggleStatus(0, res));
886 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecordToggleStatus(0, res));
887 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(106, res));
888 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(106, res));
889
890 PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMapFromDb();
891 }
892
893 class TestUsedRecordCallback : public OnPermissionUsedRecordCallbackStub {
894 public:
895 TestUsedRecordCallback() = default;
896 virtual ~TestUsedRecordCallback() = default;
OnQueried(ErrCode code,PermissionUsedResult & result)897 void OnQueried(ErrCode code, PermissionUsedResult& result) {}
898 };
899
900 /**
901 * @tc.name: GetPermissionUsedRecordsAsync001
902 * @tc.desc: test
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedRecordsAsync001, TestSize.Level4)
907 {
908 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
909 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
910 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
911 ASSERT_NE(INVALID_TOKENID, tokenID);
912
913 PermissionUsedRequest request;
914 request.tokenId = tokenID;
915 request.isRemote = false;
916 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
917
918 OHOS::sptr<TestUsedRecordCallback> cb(new (std::nothrow) TestUsedRecordCallback());
919 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecordsAsync(request, cb));
920 }
921
922 /**
923 * @tc.name: GetLockScreenStatus001
924 * @tc.desc: test
925 * @tc.type: FUNC
926 * @tc.require:
927 */
928 HWTEST_F(PermissionRecordManagerTest, GetLockScreenStatus001, TestSize.Level4)
929 {
930 EXPECT_NE(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().GetLockScreenStatus(true));
931 }
932
933 /**
934 * @tc.name: SetHapWithFGReminder001
935 * @tc.desc: test
936 * @tc.type: FUNC
937 * @tc.require:
938 */
939 HWTEST_F(PermissionRecordManagerTest, SetHapWithFGReminder001, TestSize.Level4)
940 {
941 EXPECT_NE(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().SetHapWithFGReminder(123, true));
942
943 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
944 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
945 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
946 ASSERT_NE(INVALID_TOKENID, tokenID);
947
948 EXPECT_NE(PrivacyError::ERR_PARAM_INVALID,
949 PermissionRecordManager::GetInstance().SetHapWithFGReminder(tokenID, true));
950 EXPECT_NE(PrivacyError::ERR_PARAM_INVALID,
951 PermissionRecordManager::GetInstance().SetHapWithFGReminder(tokenID, false));
952 }
953
954 /**
955 * @tc.name: GetRecordsFromLocalDBTest001
956 * @tc.desc: test GetRecordsFromLocalDB: token = 0
957 * @tc.type: FUNC
958 * @tc.require:
959 */
960 HWTEST_F(PermissionRecordManagerTest, GetRecordsFromLocalDBTest001, TestSize.Level4)
961 {
962 PermissionUsedRequest request;
963 request.tokenId = 0;
964 request.isRemote = false;
965 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
966 PermissionUsedResult result;
967 EXPECT_TRUE(PermissionRecordManager::GetInstance().GetRecordsFromLocalDB(request, result));
968 }
969
970 /**
971 * @tc.name: GetRecordsFromLocalDBTest002
972 * @tc.desc: test GetRecordsFromLocalDB: beginTimeMillis = -1
973 * @tc.type: FUNC
974 * @tc.require:
975 */
976 HWTEST_F(PermissionRecordManagerTest, GetRecordsFromLocalDBTest002, TestSize.Level4)
977 {
978 PermissionUsedRequest request;
979 request.tokenId = g_selfTokenId;
980 request.isRemote = false;
981 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
982 request.beginTimeMillis = -1; // -1 is a invalid input
983 PermissionUsedResult result;
984 EXPECT_EQ(false, PermissionRecordManager::GetInstance().GetRecordsFromLocalDB(request, result));
985 }
986
987 /*
988 * @tc.name: AddOrUpdateUsedStatusIfNeeded001
989 * @tc.desc: PermissionRecordManager::AddOrUpdateUsedStatusIfNeeded function test
990 * @tc.type: FUNC
991 * @tc.require:
992 */
993 HWTEST_F(PermissionRecordManagerTest, AddOrUpdateUsedStatusIfNeeded001, TestSize.Level4)
994 {
995 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::DataType::PERMISSION_USED_RECORD_TOGGLE_STATUS;
996 bool ret = PermissionRecordManager::GetInstance().AddOrUpdateUsedStatusIfNeeded(TEST_USER_ID_11, false);
997 EXPECT_TRUE(ret);
998
999 GenericValues conditionValue;
1000 conditionValue.Put(PrivacyFiledConst::FIELD_USER_ID, TEST_USER_ID_11);
1001 std::vector<GenericValues> results;
1002 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
1003 ASSERT_FALSE(results.empty());
1004 for (const auto& result : results) {
1005 if (TEST_USER_ID_11 == result.GetInt(PrivacyFiledConst::FIELD_USER_ID)) {
1006 ASSERT_FALSE(static_cast<bool>(result.GetInt(PrivacyFiledConst::FIELD_STATUS)));
1007 break;
1008 }
1009 }
1010 results.clear();
1011
1012 ret = PermissionRecordManager::GetInstance().AddOrUpdateUsedStatusIfNeeded(TEST_USER_ID_11, true);
1013 EXPECT_TRUE(ret);
1014 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
1015 ASSERT_FALSE(results.empty());
1016 for (const auto& result : results) {
1017 if (TEST_USER_ID_11 == result.GetInt(PrivacyFiledConst::FIELD_USER_ID)) {
1018 ASSERT_TRUE(static_cast<bool>(result.GetInt(PrivacyFiledConst::FIELD_STATUS)));
1019 break;
1020 }
1021 }
1022 }
1023
1024 /*
1025 * @tc.name: AddOrUpdateUsedTypeIfNeeded001
1026 * @tc.desc: PermissionRecordManager::AddOrUpdateUsedTypeIfNeeded function test
1027 * @tc.type: FUNC
1028 * @tc.require:
1029 */
1030 HWTEST_F(PermissionRecordManagerTest, AddOrUpdateUsedTypeIfNeeded001, TestSize.Level4)
1031 {
1032 int32_t tokenId = static_cast<int32_t>(RANDOM_TOKENID);
1033 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL);
1034 PermissionUsedType visitType = PermissionUsedType::NORMAL_TYPE;
1035 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_USED_TYPE;
1036 GenericValues conditionValue;
1037 conditionValue.Put(PrivacyFiledConst::FIELD_TOKEN_ID, tokenId);
1038 conditionValue.Put(PrivacyFiledConst::FIELD_PERMISSION_CODE, opCode);
1039
1040 // query result empty, add input type
1041 ASSERT_EQ(true, PermissionRecordManager::GetInstance().AddOrUpdateUsedTypeIfNeeded(
1042 RANDOM_TOKENID, opCode, visitType));
1043 std::vector<GenericValues> results;
1044 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
1045 ASSERT_EQ(false, results.empty());
1046 for (const auto& result : results) {
1047 if (tokenId == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
1048 ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
1049 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
1050 ASSERT_EQ(PERMISSION_USED_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
1051 break;
1052 }
1053 }
1054 results.clear();
1055
1056 // uesd type exsit and same to input type, return
1057 ASSERT_EQ(true, PermissionRecordManager::GetInstance().AddOrUpdateUsedTypeIfNeeded(
1058 RANDOM_TOKENID, opCode, visitType));
1059 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
1060 for (const auto& result : results) {
1061 if (tokenId == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
1062 ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
1063 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
1064 ASSERT_EQ(PERMISSION_USED_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
1065 break;
1066 }
1067 }
1068 results.clear();
1069
1070 visitType = PermissionUsedType::PICKER_TYPE;
1071 // used type exsit and diff from input type, update the type
1072 ASSERT_EQ(true, PermissionRecordManager::GetInstance().AddOrUpdateUsedTypeIfNeeded(
1073 RANDOM_TOKENID, opCode, visitType));
1074 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
1075 for (const auto& result : results) {
1076 if (tokenId == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
1077 ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
1078 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
1079 ASSERT_EQ(PERMISSION_USED_TYPE_WITH_PICKER_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
1080 break;
1081 }
1082 }
1083
1084 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, conditionValue));
1085 }
1086
1087 /**
1088 * @tc.name: DeletePermissionRecord001
1089 * @tc.desc: delete permission record when records excessive.
1090 * @tc.type: FUNC
1091 * @tc.require:
1092 */
1093 HWTEST_F(PermissionRecordManagerTest, DeletePermissionRecord001, TestSize.Level4)
1094 {
1095 int32_t recordSize = PermissionRecordManager::GetInstance().recordSizeMaximum_;
1096 PermissionRecordManager::GetInstance().recordSizeMaximum_ = MAX_DETAIL_NUM;
1097 std::vector<GenericValues> values;
1098 int32_t num = MAX_DETAIL_NUM + 1;
1099 AddRecord(num, values);
1100
1101 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().DeletePermissionRecord(1));
1102 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
1103 EXPECT_NE(num, PermissionUsedRecordDb::GetInstance().Count(type));
1104 for (const auto& value : values) {
1105 EXPECT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value));
1106 }
1107 PermissionRecordManager::GetInstance().recordSizeMaximum_ = recordSize;
1108 }
1109
1110 /*
1111 * @tc.name: RemoveRecordFromStartListTest001
1112 * @tc.desc: remove record from start list test
1113 * @tc.type: FUNC
1114 * @tc.require:
1115 */
1116 HWTEST_F(PermissionRecordManagerTest, RemoveRecordFromStartListTest001, TestSize.Level4)
1117 {
1118 std::set<ContinusPermissionRecord> startRecordList = PermissionRecordManager::GetInstance().startRecordList_;
1119 PermissionRecordManager::GetInstance().startRecordList_.clear();
1120 std::vector<std::string> reqPerm;
1121 reqPerm.emplace_back("ohos.permission.CAMERA");
1122 reqPerm.emplace_back("ohos.permission.MANAGE_CAMERA_CONFIG");
1123 MockHapToken mock("RemoveRecordFromStartListTest001", reqPerm, false);
1124
1125 AccessTokenID tokenId = GetSelfTokenID();
1126
1127 ActiveChangeType status = PERM_ACTIVE_IN_FOREGROUND;
1128 PermissionRecordManager::GetInstance().AddRecordToStartList(
1129 MakeInfo(tokenId, PID, "ohos.permission.CAMERA"), status, CALLER_PID);
1130 PermissionRecordManager::GetInstance().AddRecordToStartList(
1131 MakeInfo(0, PID, "ohos.permission.MICROPHONE"), status, CALLER_PID);
1132 PermissionRecordManager::GetInstance().RemoveRecordFromStartListByToken(tokenId);
1133 ASSERT_EQ(1, PermissionRecordManager::GetInstance().startRecordList_.size());
1134 PermissionRecordManager::GetInstance().startRecordList_ = startRecordList;
1135 }
1136
1137 /*
1138 * @tc.name: StartUsingPermissionTest001
1139 * @tc.desc: start using camera permission when camera global switch is close
1140 * @tc.type: FUNC
1141 * @tc.require: issueI5RWXF
1142 */
1143 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest001, TestSize.Level4)
1144 {
1145 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
1146
1147 bool isMuteCamera = CameraManagerAdapter::GetInstance().IsCameraMuted();
1148 // true means close
1149 PermissionRecordManager::GetInstance().SetMutePolicy(
1150 PolicyType::PRIVACY, CallerType::CAMERA, true, RANDOM_TOKENID);
1151
1152 auto callbackPtr = std::make_shared<PermissionRecordManagerCoverTestCb1>();
1153 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
1154 ASSERT_NE(nullptr, callbackPtr);
1155 ASSERT_NE(nullptr, callbackWrap);
1156 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
1157 g_InfoParms1.instIndex);
1158 ASSERT_NE(INVALID_TOKENID, tokenId);
1159 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
1160 MakeInfo(tokenId, PID, "ohos.permission.CAMERA"), callbackWrap->AsObject(), CALLER_PID));
1161 sleep(3); // wait for dialog disappear
1162 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StopUsingPermission(
1163 tokenId, PID, "ohos.permission.CAMERA", CALLER_PID));
1164 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::CAMERA, isMuteCamera,
1165 RANDOM_TOKENID);
1166 }
1167
1168 /*
1169 * @tc.name: CreatePermissionUsedTypeTable001
1170 * @tc.desc: PermissionUsedRecordDb::CreatePermissionUsedTypeTable function test
1171 * @tc.type: FUNC
1172 * @tc.require:
1173 */
1174 HWTEST_F(PermissionRecordManagerTest, CreatePermissionUsedTypeTable001, TestSize.Level4)
1175 {
1176 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().CreatePermissionUsedTypeTable());
1177
1178 std::map<PermissionUsedRecordDb::DataType, SqliteTable> dataTypeToSqlTable;
1179 dataTypeToSqlTable = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_; // backup
1180 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.clear();
1181
1182 ASSERT_EQ(Constant::FAILURE, PermissionUsedRecordDb::GetInstance().CreatePermissionUsedTypeTable());
1183 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
1184 }
1185
1186 /*
1187 * @tc.name: InsertPermissionUsedTypeColumn001
1188 * @tc.desc: PermissionUsedRecordDb::InsertPermissionUsedTypeColumn function test
1189 * @tc.type: FUNC
1190 * @tc.require:
1191 */
1192 HWTEST_F(PermissionRecordManagerTest, InsertPermissionUsedTypeColumn001, TestSize.Level4)
1193 {
1194 ASSERT_EQ(Constant::SUCCESS, PermissionUsedRecordDb::GetInstance().InsertPermissionUsedTypeColumn());
1195
1196 std::map<PermissionUsedRecordDb::DataType, SqliteTable> dataTypeToSqlTable;
1197 dataTypeToSqlTable = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_; // backup
1198 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.clear();
1199
1200 ASSERT_EQ(Constant::FAILURE, PermissionUsedRecordDb::GetInstance().InsertPermissionUsedTypeColumn());
1201 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
1202 }
1203
1204 /*
1205 * @tc.name: OnUpdate001
1206 * @tc.desc: PermissionUsedRecordDb::OnUpdate function test
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 HWTEST_F(PermissionRecordManagerTest, OnUpdate001, TestSize.Level4)
1211 {
1212 int32_t version = static_cast<int32_t>(PermissionUsedRecordDb::DataBaseVersion::VERISION_0);
1213 PermissionUsedRecordDb::GetInstance().OnUpdate(version);
1214
1215 version = static_cast<int32_t>(PermissionUsedRecordDb::DataBaseVersion::VERISION_1);
1216 PermissionUsedRecordDb::GetInstance().OnUpdate(version);
1217
1218 version = static_cast<int32_t>(PermissionUsedRecordDb::DataBaseVersion::VERISION_2);
1219 PermissionUsedRecordDb::GetInstance().OnUpdate(version);
1220
1221 version = static_cast<int32_t>(PermissionUsedRecordDb::DataBaseVersion::VERISION_3);
1222 PermissionUsedRecordDb::GetInstance().OnUpdate(version);
1223
1224 version = static_cast<int32_t>(PermissionUsedRecordDb::DataBaseVersion::VERISION_4);
1225 PermissionUsedRecordDb::GetInstance().OnUpdate(version);
1226
1227 auto it = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.find(
1228 PermissionUsedRecordDb::DataType::PERMISSION_USED_RECORD_TOGGLE_STATUS);
1229 ASSERT_NE(it, PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.end());
1230 ASSERT_EQ(std::string(PermissionUsedRecordDb::PERMISSION_USED_RECORD_TOGGLE_STATUS_TABLE), it->second.tableName_);
1231 }
1232 } // namespace AccessToken
1233 } // namespace Security
1234 } // namespace OHOS
1235