1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "privacy_kit_test.h"
17
18 #include <chrono>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "on_permission_used_record_callback_stub.h"
23 #include "parameter.h"
24 #define private public
25 #include "perm_active_status_change_callback.h"
26 #include "privacy_manager_client.h"
27 #include "state_change_callback.h"
28 #undef private
29 #include "perm_active_response_parcel.h"
30 #include "perm_active_status_change_callback_stub.h"
31 #include "privacy_error.h"
32 #include "privacy_kit.h"
33 #include "state_change_callback_stub.h"
34 #include "string_ex.h"
35 #include "token_setproc.h"
36
37 using namespace testing::ext;
38 using namespace OHOS::Security::AccessToken;
39
40 const static int32_t RET_NO_ERROR = 0;
41 static constexpr int32_t DEFAULT_API_VERSION = 8;
42
43 static PermissionStateFull g_infoManagerTestStateA = {
44 .permissionName = "ohos.permission.CAMERA",
45 .isGeneral = true,
46 .resDeviceID = {"local"},
47 .grantStatus = {PermissionState::PERMISSION_GRANTED},
48 .grantFlags = {1}
49 };
50 static HapPolicyParams g_policyPramsA = {
51 .apl = APL_NORMAL,
52 .domain = "test.domain.A",
53 };
54 static HapInfoParams g_infoParmsA = {
55 .userID = 1,
56 .bundleName = "ohos.privacy_test.bundleA",
57 .instIndex = 0,
58 .appIDDesc = "privacy_test.bundleA"
59 };
60
61 static PermissionStateFull g_infoManagerTestStateB = {
62 .permissionName = "ohos.permission.MICROPHONE",
63 .isGeneral = true,
64 .resDeviceID = {"local"},
65 .grantStatus = {PermissionState::PERMISSION_GRANTED},
66 .grantFlags = {1}
67 };
68 static HapPolicyParams g_policyPramsB = {
69 .apl = APL_NORMAL,
70 .domain = "test.domain.B",
71 };
72 static HapInfoParams g_infoParmsB = {
73 .userID = 1,
74 .bundleName = "ohos.privacy_test.bundleB",
75 .instIndex = 0,
76 .appIDDesc = "privacy_test.bundleB"
77 };
78
79 static PermissionDef g_infoManagerTestPermDefC = {
80 .permissionName = "ohos.permission.PERMISSION_USED_STATS",
81 .bundleName = "ohos.privacy_test.bundleC",
82 .grantMode = 1,
83 .availableLevel = APL_NORMAL,
84 .label = "labelC",
85 .labelId = 1,
86 .description = "break the door",
87 .descriptionId = 1
88 };
89 static PermissionStateFull g_infoManagerTestStateC = {
90 .permissionName = "ohos.permission.PERMISSION_USED_STATS",
91 .isGeneral = true,
92 .resDeviceID = {"localC"},
93 .grantStatus = {PermissionState::PERMISSION_GRANTED},
94 .grantFlags = {1}
95 };
96 static HapInfoParams g_infoParmsC = {
97 .userID = 1,
98 .bundleName = "ohos.privacy_test.bundleC",
99 .instIndex = 0,
100 .appIDDesc = "privacy_test.bundleC",
101 .isSystemApp = true,
102 };
103 static HapPolicyParams g_policyPramsC = {
104 .apl = APL_NORMAL,
105 .domain = "test.domain.C",
106 .permList = {g_infoManagerTestPermDefC},
107 .permStateList = {g_infoManagerTestStateC}
108 };
109
110 static HapPolicyParams g_policyPramsE = {
111 .apl = APL_NORMAL,
112 .domain = "test.domain",
113 .permList = {},
114 .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB}
115 };
116 static HapInfoParams g_infoParmsE = {
117 .userID = 1,
118 .bundleName = "ohos.privacy_test.bundleE",
119 .instIndex = 0,
120 .appIDDesc = "privacy_test.bundleE"
121 };
122
123 static UsedRecordDetail g_usedRecordDetail = {
124 .status = 2,
125 .timestamp = 2L,
126 .accessDuration = 2L,
127 };
128 static PermissionUsedRecord g_permissionUsedRecord = {
129 .permissionName = "ohos.permission.CAMERA",
130 .accessCount = 2,
131 .rejectCount = 2,
132 .lastAccessTime = 0L,
133 .lastRejectTime = 0L,
134 .lastAccessDuration = 0L,
135 };
136 static BundleUsedRecord g_bundleUsedRecord = {
137 .tokenId = 100,
138 .isRemote = false,
139 .deviceId = "you guess",
140 .bundleName = "com.ohos.test",
141 };
142
143 static HapInfoParams g_normalInfoParms = {
144 .userID = 1,
145 .bundleName = "accesstoken_test",
146 .instIndex = 0,
147 .appIDDesc = "testtesttesttest",
148 .apiVersion = DEFAULT_API_VERSION,
149 .isSystemApp = false
150 };
151 static HapInfoParams g_systemInfoParms = {
152 .userID = 1,
153 .bundleName = "accesstoken_test",
154 .instIndex = 0,
155 .appIDDesc = "testtesttesttest",
156 .apiVersion = DEFAULT_API_VERSION,
157 .isSystemApp = true
158 };
159
160 static AccessTokenID g_selfTokenId = 0;
161 static AccessTokenID g_tokenIdA = 0;
162 static AccessTokenID g_tokenIdB = 0;
163 static AccessTokenIDEx g_tokenIdC = {0};
164 static AccessTokenID g_tokenIdE = 0;
165
DeleteTestToken()166 static void DeleteTestToken()
167 {
168 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsA.userID,
169 g_infoParmsA.bundleName,
170 g_infoParmsA.instIndex);
171 AccessTokenKit::DeleteToken(tokenId);
172
173 tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsB.userID,
174 g_infoParmsB.bundleName,
175 g_infoParmsB.instIndex);
176 AccessTokenKit::DeleteToken(tokenId);
177
178 tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsC.userID,
179 g_infoParmsC.bundleName,
180 g_infoParmsC.instIndex);
181 AccessTokenKit::DeleteToken(tokenId);
182
183 tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsE.userID,
184 g_infoParmsE.bundleName,
185 g_infoParmsE.instIndex);
186 AccessTokenKit::DeleteToken(tokenId);
187
188 tokenId = AccessTokenKit::GetHapTokenID(g_normalInfoParms.userID,
189 g_normalInfoParms.bundleName,
190 g_normalInfoParms.instIndex);
191 AccessTokenKit::DeleteToken(tokenId);
192
193 tokenId = AccessTokenKit::GetHapTokenID(g_systemInfoParms.userID,
194 g_systemInfoParms.bundleName,
195 g_systemInfoParms.instIndex);
196 AccessTokenKit::DeleteToken(tokenId);
197 }
198
SetUpTestCase()199 void PrivacyKitTest::SetUpTestCase()
200 {
201 DeleteTestToken();
202 g_selfTokenId = GetSelfTokenID();
203 }
204
TearDownTestCase()205 void PrivacyKitTest::TearDownTestCase()
206 {
207 }
208
SetUp()209 void PrivacyKitTest::SetUp()
210 {
211 AccessTokenKit::AllocHapToken(g_infoParmsA, g_policyPramsA);
212 AccessTokenKit::AllocHapToken(g_infoParmsB, g_policyPramsB);
213 AccessTokenKit::AllocHapToken(g_infoParmsC, g_policyPramsC);
214 AccessTokenKit::AllocHapToken(g_infoParmsE, g_policyPramsE);
215
216 g_tokenIdA = AccessTokenKit::GetHapTokenID(g_infoParmsA.userID, g_infoParmsA.bundleName, g_infoParmsA.instIndex);
217 g_tokenIdB = AccessTokenKit::GetHapTokenID(g_infoParmsB.userID, g_infoParmsB.bundleName, g_infoParmsB.instIndex);
218 g_tokenIdC = AccessTokenKit::GetHapTokenIDEx(g_infoParmsC.userID, g_infoParmsC.bundleName, g_infoParmsC.instIndex);
219 g_tokenIdE = AccessTokenKit::GetHapTokenID(g_infoParmsE.userID, g_infoParmsE.bundleName, g_infoParmsE.instIndex);
220 }
221
TearDown()222 void PrivacyKitTest::TearDown()
223 {
224 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
225 DeleteTestToken();
226 }
227
GetLocalDeviceUdid()228 std::string PrivacyKitTest::GetLocalDeviceUdid()
229 {
230 const int32_t DEVICE_UUID_LENGTH = 65;
231 char udid[DEVICE_UUID_LENGTH] = {0};
232 GetDevUdid(udid, DEVICE_UUID_LENGTH);
233 return udid;
234 }
235
BuildQueryRequest(AccessTokenID tokenId,const std::string & deviceId,const std::string & bundleName,const std::vector<std::string> & permissionList,PermissionUsedRequest & request)236 void PrivacyKitTest::BuildQueryRequest(AccessTokenID tokenId, const std::string &deviceId,
237 const std::string &bundleName, const std::vector<std::string> &permissionList, PermissionUsedRequest &request)
238 {
239 request.tokenId = tokenId;
240 request.isRemote = false;
241 request.deviceId = deviceId;
242 request.bundleName = bundleName;
243 request.permissionList = permissionList;
244 request.beginTimeMillis = 0;
245 request.endTimeMillis = 0;
246 request.flag = FLAG_PERMISSION_USAGE_SUMMARY;
247 }
248
CheckPermissionUsedResult(const PermissionUsedRequest & request,const PermissionUsedResult & result,int32_t permRecordSize,int32_t totalSuccessCount,int32_t totalFailCount)249 void PrivacyKitTest::CheckPermissionUsedResult(const PermissionUsedRequest& request, const PermissionUsedResult& result,
250 int32_t permRecordSize, int32_t totalSuccessCount, int32_t totalFailCount)
251 {
252 int32_t successCount = 0;
253 int32_t failCount = 0;
254 ASSERT_EQ(request.tokenId, result.bundleRecords[0].tokenId);
255 ASSERT_EQ(request.isRemote, result.bundleRecords[0].isRemote);
256 ASSERT_EQ(request.deviceId, result.bundleRecords[0].deviceId);
257 ASSERT_EQ(request.bundleName, result.bundleRecords[0].bundleName);
258 ASSERT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
259 for (int32_t i = 0; i < permRecordSize; i++) {
260 successCount += result.bundleRecords[0].permissionRecords[i].accessCount;
261 failCount += result.bundleRecords[0].permissionRecords[i].rejectCount;
262 }
263 ASSERT_EQ(totalSuccessCount, successCount);
264 ASSERT_EQ(totalFailCount, failCount);
265 }
266
SleepUtilMinuteEnd()267 static void SleepUtilMinuteEnd()
268 {
269 std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(
270 std::chrono::system_clock::now().time_since_epoch()
271 );
272
273 int64_t timestampMs = ms.count();
274 time_t timestampS = static_cast<time_t>(timestampMs / 1000);
275 struct tm t = {0};
276 // localtime is not thread safe, localtime_r first param unit is second, timestamp unit is ms, so divided by 1000
277 localtime_r(×tampS, &t);
278 uint32_t sleepSeconds = static_cast<uint32_t>(60 - t.tm_sec);
279
280 GTEST_LOG_(INFO) << "current time is " << timestampMs << ", " << t.tm_hour << ":" << t.tm_min << ":" << t.tm_sec;
281 GTEST_LOG_(INFO) << "need to sleep " << sleepSeconds << " seconds";
282 sleep(sleepSeconds);
283 }
284
285 /**
286 * @tc.name: AddPermissionUsedRecord001
287 * @tc.desc: cannot AddPermissionUsedRecord with illegal tokenId and permission.
288 * @tc.type: FUNC
289 * @tc.require: issueI5P4IU
290 */
291 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord001, TestSize.Level1)
292 {
293 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(
294 0, "ohos.permission.READ_CONTACTS", 1, 0));
295 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "", 1, 0));
296 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(
297 g_tokenIdA, "ohos.permission.READ_CONTACTS", -1, 0));
298
299 PermissionUsedRequest request;
300 PermissionUsedResult result;
301 std::vector<std::string> permissionList;
302 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
303 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
304 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
305 }
306
307 /**
308 * @tc.name: AddPermissionUsedRecord002
309 * @tc.desc: cannot AddPermissionUsedRecord with invalid tokenId and permission.
310 * @tc.type: FUNC
311 * @tc.require: issueI5P4IU
312 */
313 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord002, TestSize.Level1)
314 {
315 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
316 PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.test", 1, 0));
317 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST,
318 PrivacyKit::AddPermissionUsedRecord(123, "ohos.permission.CAMERA", 1, 0));
319 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
320 PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CONTACTS", 0, 0));
321
322 PermissionUsedRequest request;
323 PermissionUsedResult result;
324 std::vector<std::string> permissionList;
325 BuildQueryRequest(123, "", "", permissionList, request);
326 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
327 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
328
329 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
330 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
331 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
332 }
333
334 /**
335 * @tc.name: AddPermissionUsedRecord003
336 * @tc.desc: cannot AddPermissionUsedRecord with native tokenId.
337 * @tc.type: FUNC
338 * @tc.require: issueI5P4IU
339 */
340 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord003, TestSize.Level1)
341 {
342 const char **dcaps = new const char *[2];
343 dcaps[0] = "AT_CAP";
344 dcaps[1] = "ST_CAP";
345 uint64_t tokenId;
346 const char **acls = new const char *[2];
347 acls[0] = "ohos.permission.test1";
348 acls[1] = "ohos.permission.test2";
349 const char **perms = new const char *[2];
350 perms[0] = "ohos.permission.test1";
351 perms[1] = "ohos.permission.test2";
352 NativeTokenInfoParams infoInstance = {
353 .dcapsNum = 2,
354 .permsNum = 2,
355 .aclsNum = 2,
356 .dcaps = dcaps,
357 .perms = perms,
358 .acls = acls,
359 .processName = "GetAccessTokenId008",
360 .aplStr = "system_core",
361 };
362 tokenId = GetAccessTokenId(&infoInstance);
363 ASSERT_NE(tokenId, static_cast<uint32_t>(0));
364
365 delete[] perms;
366 delete[] dcaps;
367 delete[] acls;
368
369 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::AddPermissionUsedRecord(
370 tokenId, "ohos.permission.READ_CONTACTS", 1, 0));
371
372 PermissionUsedRequest request;
373 PermissionUsedResult result;
374 std::vector<std::string> permissionList;
375 BuildQueryRequest(tokenId, "", "", permissionList, request);
376
377 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
378 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
379 }
380
381 /**
382 * @tc.name: AddPermissionUsedRecord004
383 * @tc.desc: AddPermissionUsedRecord user_grant permission.
384 * @tc.type: FUNC
385 * @tc.require: issueI5P4IU
386 */
387 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord004, TestSize.Level1)
388 {
389 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
390 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.WRITE_CONTACTS", 0, 1));
391 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.LOCATION", 1, 1));
392
393 PermissionUsedRequest request;
394 PermissionUsedResult result;
395 std::vector<std::string> permissionList;
396 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
397 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
398
399 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
400 CheckPermissionUsedResult(request, result, 3, 2, 2);
401 }
402
403 /**
404 * @tc.name: AddPermissionUsedRecord005
405 * @tc.desc: AddPermissionUsedRecord user_grant permission.
406 * @tc.type: FUNC
407 * @tc.require: issueI5P4IU
408 */
409 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord005, TestSize.Level1)
410 {
411 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
412 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.LOCATION", 0, 1));
413
414 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.CAMERA", 0, 1));
415 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.LOCATION", 1, 0));
416
417
418 PermissionUsedRequest request;
419 PermissionUsedResult result;
420 std::vector<std::string> permissionList;
421 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
422 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
423
424 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
425 CheckPermissionUsedResult(request, result, 2, 1, 1);
426
427 BuildQueryRequest(g_tokenIdB, GetLocalDeviceUdid(), g_infoParmsB.bundleName, permissionList, request);
428 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
429
430 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
431 CheckPermissionUsedResult(request, result, 2, 1, 1);
432
433 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
434 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
435
436 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_UNLOCKED;
437 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
438
439 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_FOREGROUND;
440 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
441
442 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_BACKGROUND;
443 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
444 }
445
446 /**
447 * @tc.name: AddPermissionUsedRecord006
448 * @tc.desc: AddPermissionUsedRecord permission combine records.
449 * @tc.type: FUNC
450 * @tc.require: issueI5P4IU
451 */
452 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord006, TestSize.Level1)
453 {
454 SleepUtilMinuteEnd();
455 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
456 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
457 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
458 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
459
460 PermissionUsedRequest request;
461 PermissionUsedResult result;
462 std::vector<std::string> permissionList;
463 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
464 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
465 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
466
467 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
468 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
469 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[0].accessRecords.size());
470 CheckPermissionUsedResult(request, result, 1, 4, 0);
471
472 sleep(61);
473
474 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
475 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
476 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
477 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
478 ASSERT_EQ(static_cast<uint32_t>(2), result.bundleRecords[0].permissionRecords[0].accessRecords.size());
479 CheckPermissionUsedResult(request, result, 1, 5, 0);
480 }
481
482 /**
483 * @tc.name: AddPermissionUsedRecord008
484 * @tc.desc: AddPermissionUsedRecord caller is normal app.
485 * @tc.type: FUNC
486 * @tc.require: issueI66BH3
487 */
488 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord008, TestSize.Level1)
489 {
490 AccessTokenIDEx tokenIdEx = {0};
491 tokenIdEx = AccessTokenKit::AllocHapToken(g_normalInfoParms, g_policyPramsA);
492 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
493 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
494
495 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA,
496 "ohos.permission.CAMERA", 1, 0));
497 ASSERT_EQ(0, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0, true));
498 }
499
500 /**
501 * @tc.name: AddPermissionUsedRecord009
502 * @tc.desc: query permission record detail count.
503 * @tc.type: FUNC
504 * @tc.require: issueI5P4IU
505 */
506 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord009, TestSize.Level1)
507 {
508 int32_t permRecordSize = 0;
509 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
510 permRecordSize++;
511 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.WRITE_CONTACTS", 0, 2));
512 permRecordSize++;
513 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.LOCATION", 3, 3));
514 permRecordSize++;
515
516 PermissionUsedRequest request;
517 PermissionUsedResult result;
518 std::vector<std::string> permissionList;
519 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
520 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
521 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
522
523 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
524 ASSERT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
525 for (int32_t i = 0; i < permRecordSize; i++) {
526 if (result.bundleRecords[0].permissionRecords[i].permissionName == "ohos.permission.CAMERA") {
527 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].accessRecords.size());
528 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords[0].permissionRecords[i].rejectRecords.size());
529 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[i].accessRecords[0].count);
530 } else if (result.bundleRecords[0].permissionRecords[i].permissionName == "ohos.permission.WRITE_CONTACTS") {
531 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords[0].permissionRecords[i].accessRecords.size());
532 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].rejectRecords.size());
533 ASSERT_EQ(2, result.bundleRecords[0].permissionRecords[i].rejectRecords[0].count);
534 } else if (result.bundleRecords[0].permissionRecords[i].permissionName == "ohos.permission.LOCATION") {
535 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].accessRecords.size());
536 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].rejectRecords.size());
537 ASSERT_EQ(3, result.bundleRecords[0].permissionRecords[i].accessRecords[0].count);
538 ASSERT_EQ(3, result.bundleRecords[0].permissionRecords[i].rejectRecords[0].count);
539 }
540 }
541 }
542
543 /**
544 * @tc.name: AddPermissionUsedRecord010
545 * @tc.desc: test record cross minute not merge.
546 * @tc.type: FUNC
547 * @tc.require: issueI5P4IU
548 */
549 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord010, TestSize.Level1)
550 {
551 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
552 SleepUtilMinuteEnd();
553 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
554
555 PermissionUsedRequest request;
556 PermissionUsedResult result;
557 std::vector<std::string> permissionList;
558 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
559 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
560 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
561
562 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
563 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
564 ASSERT_EQ(static_cast<uint32_t>(2), result.bundleRecords[0].permissionRecords[0].accessRecords.size());
565 }
566
567 /**
568 * @tc.name: RemovePermissionUsedRecords001
569 * @tc.desc: cannot RemovePermissionUsedRecords with illegal tokenId and deviceID.
570 * @tc.type: FUNC
571 * @tc.require: issueI5P4IU
572 */
573 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords001, TestSize.Level1)
574 {
575 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(0, ""));
576 }
577
578 /**
579 * @tc.name: RemovePermissionUsedRecords002
580 * @tc.desc: RemovePermissionUsedRecords with invalid tokenId and deviceID.
581 * @tc.type: FUNC
582 * @tc.require: issueI5P4IU
583 */
584 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords002, TestSize.Level1)
585 {
586 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
587 PermissionUsedRequest request;
588 PermissionUsedResult result;
589 std::vector<std::string> permissionList;
590 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
591
592 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(g_tokenIdA, "invalid_device"));
593 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
594 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
595
596 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(123, GetLocalDeviceUdid()));
597 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
598 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
599 }
600
601 /**
602 * @tc.name: RemovePermissionUsedRecords003
603 * @tc.desc: RemovePermissionUsedRecords with valid tokenId and deviceID.
604 * @tc.type: FUNC
605 * @tc.require: issueI5P4IU
606 */
607 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords003, TestSize.Level1)
608 {
609 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
610 PermissionUsedRequest request;
611 PermissionUsedResult result;
612 std::vector<std::string> permissionList;
613 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
614
615 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(g_tokenIdA, ""));
616 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
617 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
618 }
619
620 /**
621 * @tc.name: GetPermissionUsedRecords001
622 * @tc.desc: cannot GetPermissionUsedRecords with invalid query time and flag.
623 * @tc.type: FUNC
624 * @tc.require: issueI5P4IU
625 */
626 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords001, TestSize.Level1)
627 {
628 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
629 PermissionUsedRequest request;
630 PermissionUsedResult result;
631 std::vector<std::string> permissionList;
632 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
633 request.beginTimeMillis = -1;
634 request.endTimeMillis = -1;
635 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
636
637 request.beginTimeMillis = 3;
638 request.endTimeMillis = 1;
639 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
640
641 request.flag = (PermissionUsageFlag)-1;
642 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
643 }
644
645 /**
646 * @tc.name: GetPermissionUsedRecords002
647 * @tc.desc: cannot GetPermissionUsedRecords with valid query time.
648 * @tc.type: FUNC
649 * @tc.require: issueI5P4IU
650 */
651 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords002, TestSize.Level1)
652 {
653 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
654 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
655 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CALENDAR", 1, 0));
656
657 PermissionUsedRequest request;
658 PermissionUsedResult result;
659 std::vector<std::string> permissionList;
660 // query by tokenId
661 BuildQueryRequest(g_tokenIdA, "", "", permissionList, request);
662 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
663 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
664 request.deviceId = GetLocalDeviceUdid();
665 request.bundleName = g_infoParmsA.bundleName;
666 CheckPermissionUsedResult(request, result, 3, 3, 0);
667
668 // query by unmatched tokenId, deviceId and bundle Name
669 BuildQueryRequest(123, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
670 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
671 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
672
673 // query by invalid permission Name
674 permissionList.clear();
675 permissionList.emplace_back("invalid permission");
676 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
677 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
678 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
679 }
680
681 /**
682 * @tc.name: GetPermissionUsedRecords003
683 * @tc.desc: can GetPermissionUsedRecords with valid query time.
684 * @tc.type: FUNC
685 * @tc.require: issueI5P4IU
686 */
687 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords003, TestSize.Level1)
688 {
689 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
690 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
691 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
692 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
693
694 PermissionUsedRequest request;
695 PermissionUsedResult result;
696 std::vector<std::string> permissionList;
697 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
698 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
699 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
700 CheckPermissionUsedResult(request, result, 1, 4, 0);
701
702 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
703 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CALENDAR", 1, 0));
704 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.WRITE_CALENDAR", 1, 0));
705
706 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
707 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
708 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
709 CheckPermissionUsedResult(request, result, 4, 7, 0);
710 }
711
712 /**
713 * @tc.name: GetPermissionUsedRecords004
714 * @tc.desc: can GetPermissionUsedRecords with valid query time.
715 * @tc.type: FUNC
716 * @tc.require: issueI5P4IU
717 */
718 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords004, TestSize.Level1)
719 {
720 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
721 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CALENDAR", 1, 0));
722 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.CAMERA", 1, 0));
723 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.READ_CALENDAR", 1, 0));
724
725 PermissionUsedRequest request;
726 PermissionUsedResult result;
727 std::vector<std::string> permissionList;
728 BuildQueryRequest(0, GetLocalDeviceUdid(), "", permissionList, request);
729
730 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
731 if (result.bundleRecords.size() < static_cast<uint32_t>(2)) {
732 ASSERT_TRUE(false);
733 }
734 }
735
736 /**
737 * @tc.name: GetPermissionUsedRecords005
738 * @tc.desc: GetPermissionUsedRecords005 caller is normal app.
739 * @tc.type: FUNC
740 * @tc.require: issueI66BH3
741 */
742 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords005, TestSize.Level1)
743 {
744 AccessTokenIDEx tokenIdEx = {0};
745 tokenIdEx = AccessTokenKit::AllocHapToken(g_normalInfoParms, g_policyPramsA);
746 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
747 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
748
749 PermissionUsedRequest request;
750 PermissionUsedResult result;
751 std::vector<std::string> permissionList;
752 // query by tokenId
753 BuildQueryRequest(g_tokenIdA, "", "", permissionList, request);
754 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::GetPermissionUsedRecords(request, result));
755 }
756
757 /**
758 * @tc.name: GetPermissionUsedRecordsAsync001
759 * @tc.desc: cannot GetPermissionUsedRecordsAsync with invalid query time.
760 * @tc.type: FUNC
761 * @tc.require: issueI5P4IU
762 */
763 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync001, TestSize.Level1)
764 {
765 std::string permission = "ohos.permission.CAMERA";
766 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, permission, 1, 0));
767 PermissionUsedRequest request;
768 std::vector<std::string> permissionList;
769 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), "", permissionList, request);
770 request.beginTimeMillis = -1;
771 request.endTimeMillis = -1;
772 OHOS::sptr<TestCallBack> callback(new TestCallBack());
773 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, callback));
774 }
775
776 /**
777 * @tc.name: GetPermissionUsedRecordsAsync002
778 * @tc.desc: cannot GetPermissionUsedRecordsAsync with valid query time.
779 * @tc.type: FUNC
780 * @tc.require: issueI5P4IU
781 */
782 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync002, TestSize.Level1)
783 {
784 std::string permission = "ohos.permission.CAMERA";
785 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, permission, 1, 0));
786 PermissionUsedRequest request;
787 std::vector<std::string> permissionList;
788 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), "", permissionList, request);
789 OHOS::sptr<TestCallBack> callback(new TestCallBack());
790 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, callback));
791 }
792
793 class CbCustomizeTest1 : public PermActiveStatusCustomizedCbk {
794 public:
CbCustomizeTest1(const std::vector<std::string> & permList)795 explicit CbCustomizeTest1(const std::vector<std::string> &permList)
796 : PermActiveStatusCustomizedCbk(permList)
797 {
798 GTEST_LOG_(INFO) << "CbCustomizeTest1 create";
799 }
800
~CbCustomizeTest1()801 ~CbCustomizeTest1()
802 {}
803
ActiveStatusChangeCallback(ActiveChangeResponse & result)804 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
805 {
806 type_ = result.type;
807 GTEST_LOG_(INFO) << "CbCustomizeTest1 ActiveChangeResponse";
808 GTEST_LOG_(INFO) << "CbCustomizeTest1 tokenid " << result.tokenID;
809 GTEST_LOG_(INFO) << "CbCustomizeTest1 permissionName " << result.permissionName;
810 GTEST_LOG_(INFO) << "CbCustomizeTest1 deviceId " << result.deviceId;
811 GTEST_LOG_(INFO) << "CbCustomizeTest1 type " << result.type;
812 }
813
814 ActiveChangeType type_ = PERM_INACTIVE;
815 };
816
817 class CbCustomizeTest2 : public PermActiveStatusCustomizedCbk {
818 public:
CbCustomizeTest2(const std::vector<std::string> & permList)819 explicit CbCustomizeTest2(const std::vector<std::string> &permList)
820 : PermActiveStatusCustomizedCbk(permList)
821 {
822 GTEST_LOG_(INFO) << "CbCustomizeTest2 create";
823 }
824
~CbCustomizeTest2()825 ~CbCustomizeTest2()
826 {}
827
ActiveStatusChangeCallback(ActiveChangeResponse & result)828 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
829 {
830 type_ = result.type;
831 GTEST_LOG_(INFO) << "CbCustomizeTest2 ActiveChangeResponse";
832 GTEST_LOG_(INFO) << "CbCustomizeTest2 tokenid " << result.tokenID;
833 GTEST_LOG_(INFO) << "CbCustomizeTest2 permissionName " << result.permissionName;
834 GTEST_LOG_(INFO) << "CbCustomizeTest2 deviceId " << result.deviceId;
835 GTEST_LOG_(INFO) << "CbCustomizeTest2 type " << result.type;
836 }
837
838 ActiveChangeType type_;
839 };
840
841 /**
842 * @tc.name: RegisterPermActiveStatusCallback001
843 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
844 * @tc.type: FUNC
845 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
846 */
847 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback001, TestSize.Level1)
848 {
849 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
850
851 auto callbackPtr = std::make_shared<CbCustomizeTest1>(permList);
852 callbackPtr->type_ = PERM_INACTIVE;
853
854 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
855
856 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
857
858 usleep(500000); // 500000us = 0.5s
859 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
860
861 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
862
863 usleep(500000); // 500000us = 0.5s
864 ASSERT_EQ(PERM_INACTIVE, callbackPtr->type_);
865
866 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
867 callbackPtr->type_ = PERM_INACTIVE;
868
869 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
870 ASSERT_EQ(PERM_INACTIVE, callbackPtr->type_);
871
872 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
873 ASSERT_EQ(PERM_INACTIVE, callbackPtr->type_);
874 }
875
876 class CbCustomizeTest3 : public PermActiveStatusCustomizedCbk {
877 public:
CbCustomizeTest3(const std::vector<std::string> & permList)878 explicit CbCustomizeTest3(const std::vector<std::string> &permList)
879 : PermActiveStatusCustomizedCbk(permList)
880 {}
~CbCustomizeTest3()881 ~CbCustomizeTest3()
882 {}
ActiveStatusChangeCallback(ActiveChangeResponse & result)883 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
884 {
885 type_ = result.type;
886 }
887 ActiveChangeType type_ = PERM_INACTIVE;
888 };
889
890 class CbCustomizeTest4 : public StateCustomizedCbk {
891 public:
CbCustomizeTest4()892 CbCustomizeTest4()
893 {}
894
~CbCustomizeTest4()895 ~CbCustomizeTest4()
896 {}
897
StateChangeNotify(AccessTokenID tokenId,bool isShow)898 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
899 {}
900 };
901
902 /**
903 * @tc.name: RegisterPermActiveStatusCallback002
904 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
905 * @tc.type: FUNC
906 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
907 */
908 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback002, TestSize.Level1)
909 {
910 std::vector<std::string> permList1 = {"ohos.permission.CAMERA"};
911 auto callbackPtr1 = std::make_shared<CbCustomizeTest1>(permList1);
912 callbackPtr1->type_ = PERM_INACTIVE;
913
914 std::vector<std::string> permList2 = {"ohos.permission.MICROPHONE"};
915 auto callbackPtr2 = std::make_shared<CbCustomizeTest2>(permList2);
916 callbackPtr2->type_ = PERM_INACTIVE;
917
918 std::vector<std::string> permList3 = {};
919 auto callbackPtr3 = std::make_shared<CbCustomizeTest2>(permList3);
920 callbackPtr3->type_ = PERM_INACTIVE;
921
922 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
923 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr2));
924 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr3));
925
926 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
927
928 usleep(500000); // 500000us = 0.5s
929 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr1->type_);
930 ASSERT_EQ(PERM_INACTIVE, callbackPtr2->type_);
931 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr3->type_);
932
933 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
934
935 usleep(500000); // 500000us = 0.5s
936 ASSERT_EQ(PERM_INACTIVE, callbackPtr1->type_);
937 ASSERT_EQ(PERM_INACTIVE, callbackPtr3->type_);
938
939 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE"));
940
941 usleep(500000); // 500000us = 0.5s
942 ASSERT_EQ(PERM_INACTIVE, callbackPtr1->type_);
943 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr2->type_);
944
945 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE"));
946
947 usleep(500000); // 500000us = 0.5s
948 ASSERT_EQ(PERM_INACTIVE, callbackPtr2->type_);
949
950 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
951 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr2));
952 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr3));
953 }
954
955 /**
956 * @tc.name: RegisterPermActiveStatusCallback003
957 * @tc.desc: Register callback with permList which contains 1025 permissions.
958 * @tc.type: FUNC
959 * @tc.require: issueI5NT1X
960 */
961 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback003, TestSize.Level1)
962 {
963 std::vector<std::string> permList;
964 for (int32_t i = 0; i < 1024; i++) { // 1024 is the limitation
965 permList.emplace_back("ohos.permission.CAMERA");
966 }
967 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList);
968 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
969 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
970
971 permList.emplace_back("ohos.permission.MICROPHONE");
972 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
973 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
974 }
975
976 /**
977 * @tc.name: RegisterPermActiveStatusCallback004
978 * @tc.desc: Register callback 201 times.
979 * @tc.type: FUNC
980 * @tc.require: issueI5NT1X
981 */
982 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback004, TestSize.Level1)
983 {
984 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
985 std::vector<std::shared_ptr<CbCustomizeTest3>> callbackList;
986
987 for (int32_t i = 0; i <= 200; i++) { // 200 is the max size
988 if (i == 200) { // 200 is the max size
989 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
990 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
991 PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
992 break;
993 }
994 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
995 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
996 callbackList.emplace_back(callbackPtr);
997 }
998 for (int32_t i = 0; i < 200; i++) { // release 200 callback
999 auto callbackPtr = callbackList[i];
1000 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1001 }
1002 callbackList.clear();
1003 }
1004
1005 /**
1006 * @tc.name: RegisterPermActiveStatusCallback005
1007 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
1008 * @tc.type: FUNC
1009 * @tc.require: issueI5NT1X
1010 */
1011 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback005, TestSize.Level1)
1012 {
1013 std::vector<std::string> permList = {"ohos.permission.INVALD"};
1014
1015 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1016 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1017
1018 std::vector<std::string> permList1 = {"ohos.permission.INVALD", "ohos.permission.CAMERA"};
1019 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList1);
1020 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
1021 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1022 }
1023
1024 /**
1025 * @tc.name: RegisterPermActiveStatusCallback006
1026 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid callback.
1027 * @tc.type: FUNC
1028 * @tc.require: issueI5NT1X
1029 */
1030 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback006, TestSize.Level1)
1031 {
1032 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1033 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1034 ASSERT_EQ(PrivacyError::ERR_CALLBACK_NOT_EXIST, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1035 }
1036
1037 /**
1038 * @tc.name: RegisterPermActiveStatusCallback007
1039 * @tc.desc: RegisterPermActiveStatusCallback with valid permission repeatedly.
1040 * @tc.type: FUNC
1041 * @tc.require: issueI5NT1X
1042 */
1043 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback007, TestSize.Level1)
1044 {
1045 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1046 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1047 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1048 ASSERT_EQ(PrivacyError::ERR_CALLBACK_ALREADY_EXIST, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1049 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1050 ASSERT_EQ(PrivacyError::ERR_CALLBACK_NOT_EXIST, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1051 }
1052
1053 /**
1054 * @tc.name: RegisterPermActiveStatusCallback008
1055 * @tc.desc: register and startusing three permission.
1056 * @tc.type: FUNC
1057 * @tc.require: issueI5SZHG
1058 */
1059 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback008, TestSize.Level1)
1060 {
1061 std::vector<std::string> permList = {
1062 "ohos.permission.CAMERA",
1063 "ohos.permission.MICROPHONE",
1064 "ohos.permission.LOCATION"
1065 };
1066 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1067 int32_t res = PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr);
1068 ASSERT_EQ(RET_NO_ERROR, res);
1069 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA");
1070 ASSERT_EQ(RET_NO_ERROR, res);
1071 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE");
1072 ASSERT_EQ(RET_NO_ERROR, res);
1073 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.LOCATION");
1074 ASSERT_EQ(RET_NO_ERROR, res);
1075 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA");
1076 ASSERT_EQ(RET_NO_ERROR, res);
1077 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE");
1078 ASSERT_EQ(RET_NO_ERROR, res);
1079 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.LOCATION");
1080 ASSERT_EQ(RET_NO_ERROR, res);
1081 res = PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr);
1082 ASSERT_EQ(RET_NO_ERROR, res);
1083 }
1084
1085 /**
1086 * @tc.name: RegisterPermActiveStatusCallback009
1087 * @tc.desc: PrivacyManagerClient::RegisterPermActiveStatusCallback function test
1088 * @tc.type: FUNC
1089 * @tc.require: issueI61A6M
1090 */
1091 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback009, TestSize.Level1)
1092 {
1093 std::shared_ptr<PermActiveStatusCustomizedCbk> callback = nullptr;
1094 ASSERT_EQ(nullptr, callback);
1095 PrivacyManagerClient::GetInstance().RegisterPermActiveStatusCallback(callback); // callback is null
1096 }
1097
1098 /**
1099 * @tc.name: RegisterPermActiveStatusCallback010
1100 * @tc.desc: RegisterPermActiveStatusCallback caller is normal app.
1101 * @tc.type: FUNC
1102 * @tc.require: issueI66BH3
1103 */
1104 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback010, TestSize.Level1)
1105 {
1106 AccessTokenIDEx tokenIdEx = {0};
1107 tokenIdEx = AccessTokenKit::AllocHapToken(g_normalInfoParms, g_policyPramsA);
1108 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
1109 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1110
1111 std::vector<std::string> permList1 = {"ohos.permission.CAMERA"};
1112 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList1);
1113 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1114 }
1115
1116 /**
1117 * @tc.name: RegisterPermActiveStatusCallback011
1118 * @tc.desc: UnRegisterPermActiveStatusCallback caller is normal app.
1119 * @tc.type: FUNC
1120 * @tc.require: issueI66BH3
1121 */
1122 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback011, TestSize.Level1)
1123 {
1124 std::vector<std::string> permList1 = {"ohos.permission.CAMERA"};
1125 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList1);
1126 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
1127
1128 AccessTokenIDEx tokenIdEx = {0};
1129 tokenIdEx = AccessTokenKit::AllocHapToken(g_normalInfoParms, g_policyPramsA);
1130 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
1131 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1132 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1133
1134 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
1135 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1136 }
1137
1138 /**
1139 * @tc.name: IsAllowedUsingPermission001
1140 * @tc.desc: IsAllowedUsingPermission with invalid tokenId or permission.
1141 * @tc.type: FUNC
1142 * @tc.require: issueI5RWX3 issueI5RWX8
1143 */
1144 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission001, TestSize.Level1)
1145 {
1146 std::string permissionName = "ohos.permission.CAMERA";
1147 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1148 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(0, permissionName));
1149 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, ""));
1150 }
1151
1152 /**
1153 * @tc.name: IsAllowedUsingPermission002
1154 * @tc.desc: IsAllowedUsingPermission with no permission.
1155 * @tc.type: FUNC
1156 * @tc.require: issueI5RWX3 issueI5RWX8
1157 */
1158 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission002, TestSize.Level1)
1159 {
1160 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
1161 std::string permissionName = "ohos.permission.CAMERA";
1162 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1163 }
1164 /**
1165 * @tc.name: StartUsingPermission001
1166 * @tc.desc: StartUsingPermission with invalid tokenId or permission.
1167 * @tc.type: FUNC
1168 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1169 */
1170 HWTEST_F(PrivacyKitTest, StartUsingPermission001, TestSize.Level1)
1171 {
1172 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA"));
1173 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "permissionName"));
1174 }
1175
1176 /**
1177 * @tc.name: StartUsingPermission002
1178 * @tc.desc: StartUsingPermission is called twice with same permission.
1179 * @tc.type: FUNC
1180 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1181 */
1182 HWTEST_F(PrivacyKitTest, StartUsingPermission002, TestSize.Level1)
1183 {
1184 std::string permissionName = "ohos.permission.CAMERA";
1185 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1186 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
1187 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1188 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1189 }
1190
1191 /**
1192 * @tc.name: StopUsingPermission003
1193 * @tc.desc: Add record when StopUsingPermission is called.
1194 * @tc.type: FUNC
1195 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1196 */
1197 HWTEST_F(PrivacyKitTest, StartUsingPermission003, TestSize.Level1)
1198 {
1199 std::string permissionName = "ohos.permission.CAMERA";
1200 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1201 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdE, permissionName, 1, 0));
1202
1203 usleep(500000); // 500000us = 0.5s
1204 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1205
1206 PermissionUsedRequest request;
1207 PermissionUsedResult result;
1208 std::vector<std::string> permissionList;
1209 BuildQueryRequest(g_tokenIdE, GetLocalDeviceUdid(), g_infoParmsE.bundleName, permissionList, request);
1210 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
1211 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
1212 ASSERT_EQ(g_tokenIdE, result.bundleRecords[0].tokenId);
1213 ASSERT_EQ(g_infoParmsE.bundleName, result.bundleRecords[0].bundleName);
1214 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
1215 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[0].accessCount);
1216 }
1217
1218 /**
1219 * @tc.name: StartUsingPermission004
1220 * @tc.desc: StartUsingPermission basic functional verification
1221 * @tc.type: FUNC
1222 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1223 */
1224 HWTEST_F(PrivacyKitTest, StartUsingPermission004, TestSize.Level1)
1225 {
1226 std::string permissionName = "ohos.permission.CAMERA";
1227 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1228 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1229 }
1230
1231 /**
1232 * @tc.name: StartUsingPermission005
1233 * @tc.desc: StartUsingPermission with invalid tokenId or permission.
1234 * @tc.type: FUNC
1235 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1236 */
1237 HWTEST_F(PrivacyKitTest, StartUsingPermission005, TestSize.Level1)
1238 {
1239 std::string permissionName = "ohos.permission.UtTestInvalidPermission";
1240 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1241 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA"));
1242 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::StartUsingPermission(1, "ohos.permission.CAMERA"));
1243 }
1244
1245 /**
1246 * @tc.name: StartUsingPermission006
1247 * @tc.desc: StartUsingPermission with invalid tokenId or permission or callback.
1248 * @tc.type: FUNC
1249 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1250 */
1251 HWTEST_F(PrivacyKitTest, StartUsingPermission006, TestSize.Level1)
1252 {
1253 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1254 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1255 PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA", callbackPtr));
1256 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1257 PrivacyKit::StartUsingPermission(g_tokenIdE, "", callbackPtr));
1258 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1259 PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", nullptr));
1260 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1261 PrivacyKit::StartUsingPermission(g_tokenIdE, "permissionName", callbackPtr));
1262 }
1263
1264 /**
1265 * @tc.name: StartUsingPermission007
1266 * @tc.desc: StartUsingPermission is called twice with same callback.
1267 * @tc.type: FUNC
1268 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1269 */
1270 HWTEST_F(PrivacyKitTest, StartUsingPermission007, TestSize.Level1)
1271 {
1272 std::string permissionName = "ohos.permission.CAMERA";
1273 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1274 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1275 ASSERT_EQ(PrivacyError::ERR_CALLBACK_ALREADY_EXIST,
1276 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1277 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1278 }
1279
1280 /**
1281 * @tc.name: StopUsingPermission008
1282 * @tc.desc: Add record when StopUsingPermission is called.
1283 * @tc.type: FUNC
1284 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1285 */
1286 HWTEST_F(PrivacyKitTest, StopUsingPermission008, TestSize.Level1)
1287 {
1288 std::string permissionName = "ohos.permission.CAMERA";
1289 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1290 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1291 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdE, permissionName, 1, 0));
1292
1293 usleep(500000); // 500000us = 0.5s
1294 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1295
1296 PermissionUsedRequest request;
1297 PermissionUsedResult result;
1298 std::vector<std::string> permissionList;
1299 BuildQueryRequest(g_tokenIdE, GetLocalDeviceUdid(), g_infoParmsE.bundleName, permissionList, request);
1300 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
1301 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
1302 ASSERT_EQ(g_tokenIdE, result.bundleRecords[0].tokenId);
1303 ASSERT_EQ(g_infoParmsE.bundleName, result.bundleRecords[0].bundleName);
1304 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
1305 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[0].accessCount);
1306 }
1307
1308 /**
1309 * @tc.name: StartUsingPermission009
1310 * @tc.desc: StartUsingPermission basic functional verification
1311 * @tc.type: FUNC
1312 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1313 */
1314 HWTEST_F(PrivacyKitTest, StartUsingPermission009, TestSize.Level1)
1315 {
1316 std::string permissionName = "ohos.permission.CAMERA";
1317 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1318 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1319 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1320 }
1321
1322 /**
1323 * @tc.name: StartUsingPermission010
1324 * @tc.desc: StartUsingPermission caller is normal app.
1325 * @tc.type: FUNC
1326 * @tc.require: issueI66BH3
1327 */
1328 HWTEST_F(PrivacyKitTest, StartUsingPermission010, TestSize.Level1)
1329 {
1330 g_policyPramsA.permStateList.emplace_back(g_infoManagerTestStateC);
1331 AccessTokenIDEx tokenIdEx = {0};
1332 tokenIdEx = AccessTokenKit::AllocHapToken(g_normalInfoParms, g_policyPramsA);
1333 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
1334 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1335
1336 std::string permissionName = "ohos.permission.CAMERA";
1337 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1338 }
1339
1340 /**
1341 * @tc.name: StopUsingPermission001
1342 * @tc.desc: StopUsingPermission with invalid tokenId or permission.
1343 * @tc.type: FUNC
1344 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1345 */
1346 HWTEST_F(PrivacyKitTest, StopUsingPermission001, TestSize.Level1)
1347 {
1348 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, "ohos.permission.CAMERA"));
1349 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, "permissionName"));
1350 }
1351
1352 /**
1353 * @tc.name: StopUsingPermission002
1354 * @tc.desc: StopUsingPermission cancel permissions that you haven't started using
1355 * @tc.type: FUNC
1356 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1357 */
1358 HWTEST_F(PrivacyKitTest, StopUsingPermission002, TestSize.Level1)
1359 {
1360 std::string permissionName = "ohos.permission.CAMERA";
1361 ASSERT_EQ(
1362 PrivacyError::ERR_PERMISSION_NOT_START_USING, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1363 }
1364
1365 /**
1366 * @tc.name: StopUsingPermission003
1367 * @tc.desc: StopUsingPermission invalid tokenid, permission
1368 * @tc.type: FUNC
1369 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1370 */
1371 HWTEST_F(PrivacyKitTest, StopUsingPermission003, TestSize.Level1)
1372 {
1373 std::string permissionName = "ohos.permission.CAMERA";
1374 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1375 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
1376 PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.uttestpermission"));
1377 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, permissionName));
1378 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1379 }
1380
1381 /**
1382 * @tc.name: StopUsingPermission004
1383 * @tc.desc: StopUsingPermission stop a use repeatedly
1384 * @tc.type: FUNC
1385 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1386 */
1387 HWTEST_F(PrivacyKitTest, StopUsingPermission004, TestSize.Level1)
1388 {
1389 std::string permissionName = "ohos.permission.CAMERA";
1390 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1391 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1392 ASSERT_EQ(
1393 PrivacyError::ERR_PERMISSION_NOT_START_USING, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1394 }
1395
1396 /**
1397 * @tc.name: StopUsingPermission005
1398 * @tc.desc: stop use whith native token
1399 * @tc.type: FUNC
1400 * @tc.require: issueI5SZHG
1401 */
1402 HWTEST_F(PrivacyKitTest, StopUsingPermission005, TestSize.Level1)
1403 {
1404 AccessTokenID tokenId = AccessTokenKit::GetNativeTokenId("privacy_service");
1405 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::StopUsingPermission(tokenId, "ohos.permission.CAMERA"));
1406 }
1407
1408 /**
1409 * @tc.name: StopUsingPermission006
1410 * @tc.desc: StopUsingPermission caller is normal app.
1411 * @tc.type: FUNC
1412 * @tc.require: issueI66BH3
1413 */
1414 HWTEST_F(PrivacyKitTest, StopUsingPermission006, TestSize.Level1)
1415 {
1416 AccessTokenIDEx tokenIdEx = {0};
1417 tokenIdEx = AccessTokenKit::AllocHapToken(g_normalInfoParms, g_policyPramsA);
1418 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
1419 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1420
1421 std::string permissionName = "ohos.permission.CAMERA";
1422 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1423 }
1424
1425 class TestCallBack1 : public StateChangeCallbackStub {
1426 public:
1427 TestCallBack1() = default;
1428 virtual ~TestCallBack1() = default;
1429
StateChangeNotify(AccessTokenID tokenId,bool isShowing)1430 void StateChangeNotify(AccessTokenID tokenId, bool isShowing)
1431 {
1432 GTEST_LOG_(INFO) << "StateChangeNotify, tokenId is " << tokenId << ", isShowing is " << isShowing;
1433 }
1434 };
1435
1436 /**
1437 * @tc.name: OnRemoteRequest001
1438 * @tc.desc: StateChangeCallbackStub::OnRemoteRequest function test
1439 * @tc.type: FUNC
1440 * @tc.require: issueI61A6M
1441 */
1442 HWTEST_F(PrivacyKitTest, OnRemoteRequest001, TestSize.Level1)
1443 {
1444 AccessTokenID tokenId = 123; // 123 is random input
1445 bool isShowing = false;
1446
1447 TestCallBack1 callback;
1448 OHOS::MessageParcel data;
1449 ASSERT_EQ(true, data.WriteInterfaceToken(IStateChangeCallback::GetDescriptor()));
1450 ASSERT_EQ(true, data.WriteUint32(tokenId));
1451 ASSERT_EQ(true, data.WriteBool(isShowing));
1452
1453 OHOS::MessageParcel reply;
1454 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
1455 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(IStateChangeCallback::STATE_CHANGE_CALLBACK),
1456 data, reply, option)); // descriptor true + msgCode true
1457
1458 ASSERT_EQ(true, data.WriteInterfaceToken(IStateChangeCallback::GetDescriptor()));
1459 ASSERT_EQ(true, data.WriteUint32(tokenId));
1460 ASSERT_EQ(true, data.WriteBool(isShowing));
1461 uint32_t code = 10;
1462 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
1463
1464 std::string descriptor = "I don't know";
1465 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
1466 ASSERT_EQ(true, data.WriteUint32(tokenId));
1467 ASSERT_EQ(true, data.WriteBool(isShowing));
1468 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(IStateChangeCallback::STATE_CHANGE_CALLBACK),
1469 data, reply, option)); // descriptor flase + msgCode true
1470 }
1471
1472 class TestCallBack2 : public OnPermissionUsedRecordCallbackStub {
1473 public:
1474 TestCallBack2() = default;
1475 virtual ~TestCallBack2() = default;
1476
OnQueried(OHOS::ErrCode code,PermissionUsedResult & result)1477 void OnQueried(OHOS::ErrCode code, PermissionUsedResult& result)
1478 {
1479 GTEST_LOG_(INFO) << "OnQueried, code is " << code;
1480 }
1481 };
1482
1483 /**
1484 * @tc.name: OnRemoteRequest002
1485 * @tc.desc: OnPermissionUsedRecordCallbackStub::OnRemoteRequest function test
1486 * @tc.type: FUNC
1487 * @tc.require: issueI61A6M
1488 */
1489 HWTEST_F(PrivacyKitTest, OnRemoteRequest002, TestSize.Level1)
1490 {
1491 g_permissionUsedRecord.accessRecords.emplace_back(g_usedRecordDetail);
1492 g_bundleUsedRecord.permissionRecords.emplace_back(g_permissionUsedRecord);
1493
1494 int32_t errCode = 123; // 123 is random input
1495 PermissionUsedResultParcel resultParcel;
1496 resultParcel.result = {
1497 .beginTimeMillis = 0L,
1498 .endTimeMillis = 0L,
1499 };
1500 resultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord);
1501
1502 TestCallBack2 callback;
1503 OHOS::MessageParcel data;
1504 std::string descriptor = "I don't know";
1505 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
1506 ASSERT_EQ(true, data.ReadInt32(errCode));
1507 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
1508
1509 OHOS::MessageParcel reply;
1510 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
1511 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(PrivacyPermissionRecordInterfaceCode::ON_QUERIED),
1512 data, reply, option)); // descriptor false
1513
1514 ASSERT_EQ(true, data.WriteInterfaceToken(OnPermissionUsedRecordCallback::GetDescriptor()));
1515 ASSERT_EQ(true, data.ReadInt32(errCode));
1516 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
1517 uint32_t code = 10;
1518 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
1519
1520 ASSERT_EQ(true, data.WriteInterfaceToken(OnPermissionUsedRecordCallback::GetDescriptor()));
1521 ASSERT_EQ(true, data.ReadInt32(errCode));
1522 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
1523 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(PrivacyPermissionRecordInterfaceCode::ON_QUERIED),
1524 data, reply, option)); // descriptor flase + msgCode true + error != 0
1525 }
1526
1527 class TestCallBack3 : public PermActiveStatusChangeCallbackStub {
1528 public:
1529 TestCallBack3() = default;
1530 virtual ~TestCallBack3() = default;
1531
ActiveStatusChangeCallback(ActiveChangeResponse & result)1532 void ActiveStatusChangeCallback(ActiveChangeResponse& result)
1533 {
1534 GTEST_LOG_(INFO) << "ActiveStatusChangeCallback, result is " << result.type;
1535 }
1536 };
1537
1538 /**
1539 * @tc.name: OnRemoteRequest003
1540 * @tc.desc: PermActiveStatusChangeCallbackStub::OnRemoteRequest function test
1541 * @tc.type: FUNC
1542 * @tc.require: issueI61A6M
1543 */
1544 HWTEST_F(PrivacyKitTest, OnRemoteRequest003, TestSize.Level1)
1545 {
1546 ActiveChangeResponse response = {
1547 .tokenID = 123,
1548 .permissionName = "ohos.permission.CAMERA",
1549 .deviceId = "I don't know",
1550 .type = ActiveChangeType::PERM_INACTIVE
1551 };
1552
1553 ActiveChangeResponseParcel responseParcel;
1554 responseParcel.changeResponse = response;
1555
1556 TestCallBack3 callback;
1557 OHOS::MessageParcel data;
1558 std::string descriptor = "I don't know";
1559 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
1560 ASSERT_EQ(true, data.WriteParcelable(&responseParcel));
1561
1562 OHOS::MessageParcel reply;
1563 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
1564 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(
1565 PrivacyActiveChangeInterfaceCode::PERM_ACTIVE_STATUS_CHANGE), data, reply, option)); // descriptor false
1566
1567 ASSERT_EQ(true, data.WriteInterfaceToken(IPermActiveStatusCallback::GetDescriptor()));
1568 ASSERT_EQ(true, data.WriteParcelable(&responseParcel));
1569 uint32_t code = 10;
1570 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
1571 }
1572
1573 /**
1574 * @tc.name: ActiveStatusChangeCallback001
1575 * @tc.desc: PermActiveStatusChangeCallback::ActiveStatusChangeCallback function test
1576 * @tc.type: FUNC
1577 * @tc.require: issueI61A6M
1578 */
1579 HWTEST_F(PrivacyKitTest, ActiveStatusChangeCallback001, TestSize.Level1)
1580 {
1581 ActiveChangeResponse response = {
1582 .tokenID = 123,
1583 .permissionName = "ohos.permission.CAMERA",
1584 .deviceId = "I don't know",
1585 .type = ActiveChangeType::PERM_INACTIVE
1586 };
1587 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1588 std::shared_ptr<PermActiveStatusCustomizedCbk> callbackPtr = std::make_shared<CbCustomizeTest1>(permList);
1589 OHOS::sptr<PermActiveStatusChangeCallback> callback = new (
1590 std::nothrow) PermActiveStatusChangeCallback(callbackPtr);
1591 ASSERT_NE(nullptr, callback);
1592 callback->ActiveStatusChangeCallback(response); // customizedCallback_ is null
1593 }
1594
1595 /**
1596 * @tc.name: StateChangeNotify001
1597 * @tc.desc: StateChangeCallback::StateChangeNotify function test
1598 * @tc.type: FUNC
1599 * @tc.require: issueI61A6M
1600 */
1601 HWTEST_F(PrivacyKitTest, StateChangeNotify001, TestSize.Level1)
1602 {
1603 AccessTokenID tokenId = 123; // 123 is random input
1604 bool isShowing = false;
1605 std::shared_ptr<StateCustomizedCbk> callbackPtr = std::make_shared<CbCustomizeTest4>();
1606 OHOS::sptr<StateChangeCallback> callback = new (std::nothrow) StateChangeCallback(callbackPtr);
1607 ASSERT_NE(nullptr, callback);
1608 callback->StateChangeNotify(tokenId, isShowing); // customizedCallback_ is null
1609 }
1610
1611 /**
1612 * @tc.name: InitProxy001
1613 * @tc.desc: PrivacyManagerClient::InitProxy function test
1614 * @tc.type: FUNC
1615 * @tc.require: issueI61A6M
1616 */
1617 HWTEST_F(PrivacyKitTest, InitProxy001, TestSize.Level1)
1618 {
1619 ASSERT_NE(nullptr, PrivacyManagerClient::GetInstance().proxy_);
1620 OHOS::sptr<IPrivacyManager> proxy = PrivacyManagerClient::GetInstance().proxy_; // backup
1621 PrivacyManagerClient::GetInstance().proxy_ = nullptr;
1622 ASSERT_EQ(nullptr, PrivacyManagerClient::GetInstance().proxy_);
1623 PrivacyManagerClient::GetInstance().InitProxy(); // proxy_ is null
1624 PrivacyManagerClient::GetInstance().proxy_ = proxy; // recovery
1625 }
1626
1627 /**
1628 * @tc.name: StartUsingPermission008
1629 * @tc.desc: PrivacyKit:: function test input invalid
1630 * @tc.type: FUNC
1631 * @tc.require: issueI61A6M
1632 */
1633 HWTEST_F(PrivacyKitTest, StartUsingPermission008, TestSize.Level1)
1634 {
1635 AccessTokenID tokenId = 0;
1636 std::string permissionName;
1637 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(tokenId, permissionName));
1638 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(tokenId, permissionName));
1639 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(tokenId, permissionName));
1640 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(tokenId, permissionName));
1641 }
1642
1643 #ifdef SECURITY_COMPONENT_ENHANCE_ENABLE
1644 /**
1645 * @tc.name: StartUsingPermission008
1646 * @tc.desc: PrivacyKit:: function test register enhance data
1647 * @tc.type: FUNC
1648 * @tc.require: issueI7MXZ
1649 */
1650 HWTEST_F(PrivacyKitTest, RegisterSecCompEnhance001, TestSize.Level1)
1651 {
1652 SetSelfTokenID(g_tokenIdA);
1653 SecCompEnhanceData data;
1654 data.callback = nullptr;
1655 data.challenge = 0;
1656 EXPECT_EQ(PrivacyError::ERR_WRITE_PARCEL_FAILED, PrivacyKit::RegisterSecCompEnhance(data));
1657
1658 // StateChangeCallback is not the real callback of SecCompEnhance, but it does not effect the final result.
1659 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1660 data.callback = new (std::nothrow) StateChangeCallback(callbackPtr);
1661 EXPECT_EQ(RET_SUCCESS, PrivacyKit::RegisterSecCompEnhance(data));
1662
1663 AccessTokenID secCompId = AccessTokenKit::GetNativeTokenId("security_component_service");
1664 EXPECT_EQ(0, SetSelfTokenID(secCompId));
1665 SecCompEnhanceData data1;
1666 EXPECT_EQ(RET_SUCCESS, PrivacyKit::GetSecCompEnhance(getpid(), data1));
1667 EXPECT_NE(RET_SUCCESS, PrivacyKit::GetSecCompEnhance(0, data1));
1668 }
1669
1670 /**
1671 * @tc.name: GetSpecialSecCompEnhance001
1672 * @tc.desc: PrivacyKit:: function test Get Special enhance
1673 * @tc.type: FUNC
1674 * @tc.require: issueI7MXZ
1675 */
1676 HWTEST_F(PrivacyKitTest, GetSpecialSecCompEnhance001, TestSize.Level1)
1677 {
1678 AccessTokenID secCompId = AccessTokenKit::GetNativeTokenId("security_component_service");
1679 EXPECT_EQ(0, SetSelfTokenID(secCompId));
1680
1681 std::vector<SecCompEnhanceData> res;
1682 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetSpecialSecCompEnhance("", res));
1683 ASSERT_EQ(static_cast<int32_t>(res.size()), 0);
1684 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetSpecialSecCompEnhance(g_infoParmsA.bundleName, res));
1685 }
1686 #endif
1687