1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "file_permission_test.h"
16 #include <cassert>
17 #include <fcntl.h>
18 
19 #include <singleton.h>
20 #include <string>
21 #include <sys/mount.h>
22 #include <sys/stat.h>
23 #include <sys/types.h>
24 
25 #include "access_token_error.h"
26 #include "accesstoken_kit.h"
27 #include "file_permission.h"
28 #include "ipc_skeleton.h"
29 #include "log.h"
30 #include "parameter.h"
31 #include "sandbox_helper.h"
32 #include "uri.h"
33 
34 #include "nativetoken_kit.h"
35 #include "permission_def.h"
36 #include "permission_state_full.h"
37 #include "token_setproc.h"
38 
39 using namespace testing;
40 using namespace testing::ext;
41 namespace OHOS {
42 namespace AppFileService {
43 #ifdef SANDBOX_MANAGER
44 const char *g_fileManagerFullMountEnableParameter = "const.filemanager.full_mount.enable";
45 #endif
46 const std::string SET_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY";
47 const std::string ACCESS_PERSIST_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST";
48 const std::string READ_WRITE_DOWNLOAD_PERMISSION = "ohos.permission.READ_WRITE_DOWNLOAD_DIRECTORY";
49 const std::string BUNDLE_NAME_A = "com.example.filesharea";
50 uint64_t g_mockToken;
51 OHOS::Security::AccessToken::PermissionStateFull g_testState1 = {
52     .permissionName = SET_POLICY_PERMISSION,
53     .isGeneral = true,
54     .resDeviceID = {"1"},
55     .grantStatus = {0},
56     .grantFlags = {0},
57 };
58 OHOS::Security::AccessToken::PermissionStateFull g_testState2 = {
59     .permissionName = ACCESS_PERSIST_PERMISSION,
60     .isGeneral = true,
61     .resDeviceID = {"1"},
62     .grantStatus = {0},
63     .grantFlags = {0},
64 };
65 OHOS::Security::AccessToken::PermissionStateFull g_testState3 = {
66     .permissionName = READ_WRITE_DOWNLOAD_PERMISSION,
67     .isGeneral = true,
68     .resDeviceID = {"1"},
69     .grantStatus = {0},
70     .grantFlags = {0},
71 };
72 OHOS::Security::AccessToken::HapInfoParams g_testInfoParams = {
73     .userID = 1,
74     .bundleName = BUNDLE_NAME_A,
75     .instIndex = 0,
76     .appIDDesc = "test",
77 };
78 OHOS::Security::AccessToken::HapPolicyParams g_testPolicyParams = {
79     .apl = OHOS::Security::AccessToken::APL_NORMAL,
80     .domain = "test.domain",
81     .permList = {},
82     .permStateList = {g_testState1, g_testState2, g_testState3},
83 };
84 
NativeTokenGet()85 void NativeTokenGet()
86 {
87     uint64_t fullTokenId;
88     const char **perms = new const char *[1];
89     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
90     NativeTokenInfoParams infoInstance = {
91         .permsNum = 1,
92         .aclsNum = 0,
93         .dcaps = nullptr,
94         .perms = perms,
95         .dcapsNum = 0,
96         .acls = nullptr,
97         .aplStr = "system_core",
98     };
99     infoInstance.processName = "TestCase";
100     fullTokenId = GetAccessTokenId(&infoInstance);
101     EXPECT_EQ(0, SetSelfTokenID(fullTokenId));
102     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
103     delete[] perms;
104 }
SetUpTestCase()105 void FilePermissionTest::SetUpTestCase()
106 {
107     NativeTokenGet();
108     OHOS::Security::AccessToken::AccessTokenID tokenId =
109         OHOS::Security::AccessToken::AccessTokenKit::GetNativeTokenId("foundation");
110     EXPECT_EQ(0, SetSelfTokenID(tokenId));
111     OHOS::Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
112     tokenIdEx = OHOS::Security::AccessToken::AccessTokenKit::AllocHapToken(g_testInfoParams, g_testPolicyParams);
113     g_mockToken = tokenIdEx.tokenIdExStruct.tokenID;
114     EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIdExStruct.tokenID));
115     #ifdef SANDBOX_MANAGER
116     sandboxMock_ = make_shared<SandboxMock>();
117     SandboxMock::sandboxManagerKitMock = sandboxMock_;
118     upmsMock_ = make_shared<UpmsMock>();
119     UpmsMock::upmsManagerKitMock = upmsMock_;
120     #endif
121 }
TearDownTestCase()122 void FilePermissionTest::TearDownTestCase()
123 {
124     OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(g_mockToken);
125     #ifdef SANDBOX_MANAGER
126     SandboxMock::sandboxManagerKitMock = nullptr;
127     sandboxMock_ = nullptr;
128     UpmsMock::upmsManagerKitMock = nullptr;
129     upmsMock_ = nullptr;
130     #endif
131 }
132 
133 #ifdef SANDBOX_MANAGER
CheckFileManagerFullMountEnable()134 static bool CheckFileManagerFullMountEnable()
135 {
136     char value[] = "false";
137     int retSystem = GetParameter(g_fileManagerFullMountEnableParameter, "false", value, sizeof(value));
138     if (retSystem > 0 && !std::strcmp(value, "true")) {
139         return true;
140     }
141     LOGE("Not supporting all mounts");
142     return false;
143 }
144 
145 /**
146  * @tc.name: PersistPermission_test_0000
147  * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
148  * @tc.size: MEDIUM
149  * @tc.type: FUNC
150  * @tc.level Level 1
151  * @tc.require:
152  */
153 HWTEST_F(FilePermissionTest, PersistPermission_test_0000, testing::ext::TestSize.Level1)
154 {
155     GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0000";
156     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
157                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
158     std::vector<UriPolicyInfo> uriPolicies;
159     uriPolicies.emplace_back(infoA);
160     deque<struct PolicyErrorResult> errorResults;
161     EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
162     int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
163     EXPECT_EQ(ret, 0);
164     GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0000";
165 }
166 /**
167  * @tc.name: PersistPermission_test_0001
168  * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
169  * @tc.size: MEDIUM
170  * @tc.type: FUNC
171  * @tc.level Level 1
172  * @tc.require:
173  */
174 HWTEST_F(FilePermissionTest, PersistPermission_test_0001, testing::ext::TestSize.Level1)
175 {
176     GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0001";
177     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
178                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
179     UriPolicyInfo infoB = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
180     std::vector<UriPolicyInfo> uriPolicies;
181     uriPolicies.emplace_back(infoA);
182     uriPolicies.emplace_back(infoB);
183     deque<struct PolicyErrorResult> errorResults;
184     vector<uint32_t> resultCodes;
185     resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
186     EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
187         .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
188     int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
189     if (CheckFileManagerFullMountEnable()) {
190         EXPECT_EQ(ret, EPERM);
191         EXPECT_EQ(INVALID_MODE, errorResults[0].code);
192     } else {
193         EXPECT_EQ(ret, EPERM);
194     };
195     GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0001";
196 }
197 /**
198  * @tc.name: PersistPermission_test_0002
199  * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
200  * @tc.size: MEDIUM
201  * @tc.type: FUNC
202  * @tc.level Level 1
203  * @tc.require:
204  */
205 HWTEST_F(FilePermissionTest, PersistPermission_test_0002, testing::ext::TestSize.Level1)
206 {
207     GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0002";
208     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
209                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
210     std::vector<UriPolicyInfo> uriPolicies;
211     uriPolicies.emplace_back(infoA);
212     deque<struct PolicyErrorResult> errorResults;
213     EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
214     int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
215     if (CheckFileManagerFullMountEnable()) {
216         EXPECT_EQ(ret, EPERM);
217         ASSERT_EQ(uriPolicies.size(), errorResults.size());
218         EXPECT_EQ(INVALID_PATH, errorResults[0].code);
219     } else {
220         EXPECT_EQ(ret, EPERM);
221     };
222     GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0002";
223 }
224 /**
225  * @tc.name: ActivatePermission_test_0000
226  * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
227  * @tc.size: MEDIUM
228  * @tc.type: FUNC
229  * @tc.level Level 1
230  * @tc.require:
231  */
232 HWTEST_F(FilePermissionTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1)
233 {
234     GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0000";
235     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
236                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
237     std::vector<UriPolicyInfo> uriPolicies;
238     uriPolicies.emplace_back(infoA);
239     deque<struct PolicyErrorResult> errorResults;
240     EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
241     int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
242     EXPECT_EQ(ret, 0);
243     GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0000";
244 }
245 /**
246  * @tc.name: ActivatePermission_test_0001
247  * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
248  * @tc.size: MEDIUM
249  * @tc.type: FUNC
250  * @tc.level Level 1
251  * @tc.require:
252  */
253 HWTEST_F(FilePermissionTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1)
254 {
255     GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0001";
256     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
257                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
258     UriPolicyInfo infoB = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
259     std::vector<UriPolicyInfo> uriPolicies;
260     uriPolicies.emplace_back(infoA);
261     uriPolicies.emplace_back(infoB);
262     deque<struct PolicyErrorResult> errorResults;
263     vector<uint32_t> resultCodes;
264     resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
265     EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
266     int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
267     if (CheckFileManagerFullMountEnable()) {
268         EXPECT_EQ(ret, EPERM);
269         EXPECT_EQ(INVALID_MODE, errorResults[0].code);
270     } else {
271         EXPECT_EQ(ret, EPERM);
272     };
273     GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0001";
274 }
275 /**
276  * @tc.name: ActivatePermission_test_0002
277  * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
278  * @tc.size: MEDIUM
279  * @tc.type: FUNC
280  * @tc.level Level 1
281  * @tc.require:
282  */
283 HWTEST_F(FilePermissionTest, ActivatePermission_test_0002, testing::ext::TestSize.Level1)
284 {
285     GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0002";
286     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
287                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
288     std::vector<UriPolicyInfo> uriPolicies;
289     uriPolicies.emplace_back(infoA);
290     deque<struct PolicyErrorResult> errorResults;
291     EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
292     int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
293     if (CheckFileManagerFullMountEnable()) {
294         EXPECT_EQ(ret, EPERM);
295         ASSERT_EQ(uriPolicies.size(), errorResults.size());
296         EXPECT_EQ(INVALID_PATH, errorResults[0].code);
297     } else {
298         EXPECT_EQ(ret, EPERM);
299     };
300     GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0002";
301 }
302 /**
303  * @tc.name: DeactivatePermission_test_0000
304  * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
305  * @tc.size: MEDIUM
306  * @tc.type: FUNC
307  * @tc.level Level 1
308  * @tc.require:
309  */
310 HWTEST_F(FilePermissionTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1)
311 {
312     GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0000";
313     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
314                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
315     std::vector<UriPolicyInfo> uriPolicies;
316     uriPolicies.emplace_back(infoA);
317     deque<struct PolicyErrorResult> errorResults;
318     EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
319     int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
320     EXPECT_EQ(ret, 0);
321     GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0000";
322 }
323 /**
324  * @tc.name: DeactivatePermission_test_0001
325  * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
326  * @tc.size: MEDIUM
327  * @tc.type: FUNC
328  * @tc.level Level 1
329  * @tc.require:
330  */
331 HWTEST_F(FilePermissionTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1)
332 {
333     GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0001";
334     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
335                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
336     UriPolicyInfo infoB = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
337     std::vector<UriPolicyInfo> uriPolicies;
338     uriPolicies.emplace_back(infoA);
339     uriPolicies.emplace_back(infoB);
340     deque<struct PolicyErrorResult> errorResults;
341     vector<uint32_t> resultCodes;
342     resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
343     EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _))
344         .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
345     int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
346     if (CheckFileManagerFullMountEnable()) {
347         EXPECT_EQ(ret, EPERM);
348         EXPECT_EQ(INVALID_MODE, errorResults[0].code);
349     } else {
350         EXPECT_EQ(ret, EPERM);
351     };
352     GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0001";
353 }
354 /**
355  * @tc.name: DeactivatePermission_test_0002
356  * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
357  * @tc.size: MEDIUM
358  * @tc.type: FUNC
359  * @tc.level Level 1
360  * @tc.require:
361  */
362 HWTEST_F(FilePermissionTest, DeactivatePermission_test_0002, testing::ext::TestSize.Level1)
363 {
364     GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0002";
365     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
366                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
367     std::vector<UriPolicyInfo> uriPolicies;
368     uriPolicies.emplace_back(infoA);
369     deque<struct PolicyErrorResult> errorResults;
370     EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
371     int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
372     if (CheckFileManagerFullMountEnable()) {
373         EXPECT_EQ(ret, EPERM);
374         ASSERT_EQ(uriPolicies.size(), errorResults.size());
375         EXPECT_EQ(INVALID_PATH, errorResults[0].code);
376     } else {
377         EXPECT_EQ(ret, EPERM);
378     };
379     GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0002";
380 }
381 /**
382  * @tc.name: RevokePermission_test_0000
383  * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
384  * @tc.size: MEDIUM
385  * @tc.type: FUNC
386  * @tc.level Level 1
387  * @tc.require:
388  */
389 HWTEST_F(FilePermissionTest, RevokePermission_test_0000, testing::ext::TestSize.Level1)
390 {
391     GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_0000";
392     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
393                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
394     std::vector<UriPolicyInfo> uriPolicies;
395     uriPolicies.emplace_back(infoA);
396     deque<struct PolicyErrorResult> errorResults;
397     EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
398     int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
399     EXPECT_EQ(ret, 0);
400     GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_0000";
401 }
402 /**
403  * @tc.name: RevokePermission_test_0001
404  * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
405  * @tc.size: MEDIUM
406  * @tc.type: FUNC
407  * @tc.level Level 1
408  * @tc.require:
409  */
410 HWTEST_F(FilePermissionTest, RevokePermission_test_0001, testing::ext::TestSize.Level1)
411 {
412     GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_0001";
413     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
414     std::vector<UriPolicyInfo> uriPolicies;
415     uriPolicies.emplace_back(infoA);
416     deque<struct PolicyErrorResult> errorResults;
417     vector<uint32_t> resultCodes;
418     resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
419     EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _))
420         .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
421     int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
422     if (CheckFileManagerFullMountEnable()) {
423         EXPECT_EQ(ret, EPERM);
424         EXPECT_EQ(INVALID_MODE, errorResults[0].code);
425     } else {
426         EXPECT_EQ(ret, EPERM);
427     };
428     GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_0001";
429 }
430 /**
431  * @tc.name: RevokePermission_test_0002
432  * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
433  * @tc.size: MEDIUM
434  * @tc.type: FUNC
435  * @tc.level Level 1
436  * @tc.require:
437  */
438 HWTEST_F(FilePermissionTest, RevokePermission_test_0002, testing::ext::TestSize.Level1)
439 {
440     GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_0002";
441     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
442                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
443     std::vector<UriPolicyInfo> uriPolicies;
444     uriPolicies.emplace_back(infoA);
445     deque<struct PolicyErrorResult> errorResults;
446     EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
447     int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
448     if (CheckFileManagerFullMountEnable()) {
449         EXPECT_EQ(ret, EPERM);
450         ASSERT_EQ(uriPolicies.size(), errorResults.size());
451         EXPECT_EQ(INVALID_PATH, errorResults[0].code);
452     } else {
453         EXPECT_EQ(ret, EPERM);
454     };
455     GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_0002";
456 }
457 /**
458  * @tc.name: GetPathByPermission_test_0001
459  * @tc.desc: Test function of GetPathByPermission() interface for SUCCESS.
460  * @tc.size: MEDIUM
461  * @tc.type: FUNC
462  * @tc.level Level 1
463  * @tc.require:
464  */
465 HWTEST_F(FilePermissionTest, GetPathByPermission_test_0001, testing::ext::TestSize.Level1)
466 {
467     GTEST_LOG_(INFO) << "FileShareTest-begin GetPathByPermission_test_0001";
468     std::string PermissionName = "ohos.permission.READ_WRITE_DOWNLOAD_DIRECTORY";
469     std::string sandboxPath = "/storage/Users/currentUser/Download";
470     std::string path = FilePermission::GetPathByPermission(PermissionName);
471     if (CheckFileManagerFullMountEnable()) {
472         EXPECT_EQ(path, sandboxPath);
473     } else {
474         EXPECT_EQ(path, sandboxPath);
475     };
476     GTEST_LOG_(INFO) << "FileShareTest-end GetPathByPermission_test_0001";
477 }
478 /**
479  * @tc.name: GetPathByPermission_test_0002
480  * @tc.desc: Test function of GetPathByPermission() interface for SUCCESS.
481  * @tc.size: MEDIUM
482  * @tc.type: FUNC
483  * @tc.level Level 1
484  * @tc.require:
485  */
486 HWTEST_F(FilePermissionTest, GetPathByPermission_test_0002, testing::ext::TestSize.Level1)
487 {
488     GTEST_LOG_(INFO) << "FileShareTest-begin GetPathByPermission_test_0002";
489     std::string PermissionName = "ohos.permission.READ_WRITE_DESKTOP_DIRECTORY";
490     std::string sandboxPath = "/storage/Users/currentUser/Desktop";
491     std::string path = FilePermission::GetPathByPermission(PermissionName);
492     if (CheckFileManagerFullMountEnable()) {
493         EXPECT_EQ(path, sandboxPath);
494     } else {
495         EXPECT_EQ(path, sandboxPath);
496     };
497     GTEST_LOG_(INFO) << "FileShareTest-end GetPathByPermission_test_0002";
498 }
499 /**
500  * @tc.name: GetPathByPermission_test_0003
501  * @tc.desc: Test function of GetPathByPermission() interface for SUCCESS.
502  * @tc.size: MEDIUM
503  * @tc.type: FUNC
504  * @tc.level Level 1
505  * @tc.require:
506  */
507 HWTEST_F(FilePermissionTest, GetPathByPermission_test_0003, testing::ext::TestSize.Level1)
508 {
509     GTEST_LOG_(INFO) << "FileShareTest-begin GetPathByPermission_test_0003";
510     std::string PermissionName = "ohos.permission.READ_WRITE_DOCUMENTS_DIRECTORY";
511     std::string sandboxPath = "/storage/Users/currentUser/Documents";
512     std::string path = FilePermission::GetPathByPermission(PermissionName);
513     if (CheckFileManagerFullMountEnable()) {
514         EXPECT_EQ(path, sandboxPath);
515     } else {
516         EXPECT_EQ(path, sandboxPath);
517     };
518     GTEST_LOG_(INFO) << "FileShareTest-end GetPathByPermission_test_0003";
519 }
520 /**
521  * @tc.name: CheckPersistentPermission_test_0001
522  * @tc.desc: Test function of CheckPersistentPermission() interface for SUCCESS.
523  * @tc.size: MEDIUM
524  * @tc.type: FUNC
525  * @tc.level Level 1
526  * @tc.require:
527  */
528 HWTEST_F(FilePermissionTest, CheckPersistentPermission_test_0001, testing::ext::TestSize.Level1)
529 {
530     GTEST_LOG_(INFO) << "FileShareTest-begin CheckPersistentPermission_test_0001";
531     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
532                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
533     std::vector<UriPolicyInfo> uriPolicies;
534     uriPolicies.emplace_back(infoA);
535     vector<bool> errorResults;
536     EXPECT_CALL(*sandboxMock_, CheckPersistPolicy(_, _, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
537     int32_t ret = FilePermission::CheckPersistentPermission(uriPolicies, errorResults);
538     if (CheckFileManagerFullMountEnable()) {
539         EXPECT_EQ(ret, 0);
540         ASSERT_EQ(uriPolicies.size(), errorResults.size());
541         EXPECT_EQ(false, errorResults[0]);
542     } else {
543         EXPECT_EQ(ret, 0);
544     };
545     GTEST_LOG_(INFO) << "FileShareTest-end CheckPersistentPermission_test_0001";
546 }
547 /**
548  * @tc.name: CheckPersistentPermission_test_0002
549  * @tc.desc: Test function of CheckPersistentPermission() interface for SUCCESS.
550  * @tc.size: MEDIUM
551  * @tc.type: FUNC
552  * @tc.level Level 1
553  * @tc.require:
554  */
555 HWTEST_F(FilePermissionTest, CheckPersistentPermission_test_0002, testing::ext::TestSize.Level1)
556 {
557     GTEST_LOG_(INFO) << "FileShareTest-begin CheckPersistentPermission_test_0002";
558     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
559                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
560     std::vector<UriPolicyInfo> uriPolicies;
561     uriPolicies.emplace_back(infoA);
562     deque<struct PolicyErrorResult> errorResults;
563     EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
564     EXPECT_CALL(*sandboxMock_, CheckPersistPolicy(_, _, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
565     int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
566     EXPECT_EQ(ret, 0);
567     vector<bool> errorResult;
568     ret = FilePermission::CheckPersistentPermission(uriPolicies, errorResult);
569     if (CheckFileManagerFullMountEnable()) {
570         EXPECT_EQ(ret, 0);
571         ASSERT_EQ(uriPolicies.size(), errorResult.size());
572         EXPECT_EQ(true, errorResult[0]);
573     } else {
574         EXPECT_EQ(ret, 0);
575     };
576     EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
577     ret = FilePermission::RevokePermission(uriPolicies, errorResults);
578     GTEST_LOG_(INFO) << "FileShareTest-end CheckPersistentPermission_test_0002";
579 }
580 /**
581  * @tc.name: CheckPersistentPermission_test_0003
582  * @tc.desc: Test function of CheckPersistentPermission() interface for SUCCESS.
583  * @tc.size: MEDIUM
584  * @tc.type: FUNC
585  * @tc.level Level 1
586  * @tc.require:
587  */
588 HWTEST_F(FilePermissionTest, CheckPersistentPermission_test_0003, testing::ext::TestSize.Level1)
589 {
590     GTEST_LOG_(INFO) << "FileShareTest-begin CheckPersistentPermission_test_0003";
591     UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/001.txt",
592                            .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
593     std::vector<UriPolicyInfo> uriPolicies;
594     uriPolicies.emplace_back(infoA);
595     vector<bool> errorResult;
596     int32_t ret = FilePermission::CheckPersistentPermission(uriPolicies, errorResult);
597     if (CheckFileManagerFullMountEnable()) {
598         EXPECT_EQ(ret, EPERM);
599         ASSERT_EQ(uriPolicies.size(), errorResult.size());
600         EXPECT_EQ(false, errorResult[0]);
601     } else {
602         EXPECT_EQ(ret, EPERM);
603     };
604     GTEST_LOG_(INFO) << "FileShareTest-end CheckPersistentPermission_test_0003";
605 }
606 #endif
607 } // namespace AppFileService
608 } // namespace OHOS