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