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
fseeko(FILE * stream,off_t offset,int whence)39 int fseeko(FILE *stream, off_t offset, int whence)
40 {
41 if (OHOS::AppFileService::LibraryFunc::libraryFunc_ == nullptr) {
42 return -1;
43 }
44 return OHOS::AppFileService::LibraryFunc::libraryFunc_->fseeko(stream, offset, whence);
45 }
46
access(const char * pathname,int mode)47 int access(const char *pathname, int mode)
48 {
49 if (OHOS::AppFileService::LibraryFunc::libraryFunc_ == nullptr) {
50 return -1;
51 }
52 return OHOS::AppFileService::LibraryFunc::libraryFunc_->access(pathname, mode);
53 }
54
55 using namespace testing;
56 using namespace testing::ext;
57 namespace OHOS {
58 namespace AppFileService {
59 const std::string SET_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY";
60 const std::string ACCESS_PERSIST_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST";
61 const std::string READ_WRITE_DOWNLOAD_PERMISSION = "ohos.permission.READ_WRITE_DOWNLOAD_DIRECTORY";
62 const std::string BUNDLE_NAME_A = "com.example.filesharea";
63 uint64_t g_mockToken;
64 OHOS::Security::AccessToken::PermissionStateFull g_testState1 = {
65 .permissionName = SET_POLICY_PERMISSION,
66 .isGeneral = true,
67 .resDeviceID = {"1"},
68 .grantStatus = {0},
69 .grantFlags = {0},
70 };
71 OHOS::Security::AccessToken::PermissionStateFull g_testState2 = {
72 .permissionName = ACCESS_PERSIST_PERMISSION,
73 .isGeneral = true,
74 .resDeviceID = {"1"},
75 .grantStatus = {0},
76 .grantFlags = {0},
77 };
78 OHOS::Security::AccessToken::PermissionStateFull g_testState3 = {
79 .permissionName = READ_WRITE_DOWNLOAD_PERMISSION,
80 .isGeneral = true,
81 .resDeviceID = {"1"},
82 .grantStatus = {0},
83 .grantFlags = {0},
84 };
85 OHOS::Security::AccessToken::HapInfoParams g_testInfoParams = {
86 .userID = 1,
87 .bundleName = BUNDLE_NAME_A,
88 .instIndex = 0,
89 .appIDDesc = "test",
90 };
91 OHOS::Security::AccessToken::HapPolicyParams g_testPolicyParams = {
92 .apl = OHOS::Security::AccessToken::APL_NORMAL,
93 .domain = "test.domain",
94 .permList = {},
95 .permStateList = {g_testState1, g_testState2, g_testState3},
96 };
97
SetUpTestCase()98 void FilePermissionTest::SetUpTestCase()
99 {
100 OHOS::Security::AccessToken::AccessTokenID tokenId =
101 OHOS::Security::AccessToken::AccessTokenKit::GetNativeTokenId("foundation");
102 EXPECT_EQ(0, SetSelfTokenID(tokenId));
103 OHOS::Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
104 tokenIdEx = OHOS::Security::AccessToken::AccessTokenKit::AllocHapToken(g_testInfoParams, g_testPolicyParams);
105 g_mockToken = tokenIdEx.tokenIdExStruct.tokenID;
106 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIdExStruct.tokenID));
107 #ifdef SANDBOX_MANAGER
108 sandboxMock_ = make_shared<SandboxMock>();
109 SandboxMock::sandboxManagerKitMock = sandboxMock_;
110 funcMock = make_shared<LibraryFuncMock>();
111 LibraryFuncMock::libraryFunc_ = funcMock;
112 upmsMock_ = make_shared<UpmsMock>();
113 UpmsMock::upmsManagerKitMock = upmsMock_;
114 #endif
115 }
TearDownTestCase()116 void FilePermissionTest::TearDownTestCase()
117 {
118 OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(g_mockToken);
119 #ifdef SANDBOX_MANAGER
120 SandboxMock::sandboxManagerKitMock = nullptr;
121 sandboxMock_ = nullptr;
122 LibraryFuncMock::libraryFunc_ = nullptr;
123 funcMock = nullptr;
124 UpmsMock::upmsManagerKitMock = nullptr;
125 upmsMock_ = nullptr;
126 #endif
127 }
128
129 #ifdef SANDBOX_MANAGER
130
131 /**
132 * @tc.name: PersistPermission_test_0000
133 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
134 * @tc.size: MEDIUM
135 * @tc.type: FUNC
136 * @tc.level Level 1
137 * @tc.require:
138 */
139 HWTEST_F(FilePermissionTest, PersistPermission_test_0000, testing::ext::TestSize.Level1)
140 {
141 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0000";
142 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
143 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
144 std::vector<UriPolicyInfo> uriPolicies;
145 uriPolicies.emplace_back(infoA);
146 deque<struct PolicyErrorResult> errorResults;
147 vector<uint32_t> resultCodes;
148 resultCodes.push_back(PolicyErrorCode::INVALID_PATH);
149 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
150 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
151 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
152 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
153 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
154 EXPECT_EQ(ret, EPERM);
155 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0000";
156 }
157 /**
158 * @tc.name: PersistPermission_test_0001
159 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
160 * @tc.size: MEDIUM
161 * @tc.type: FUNC
162 * @tc.level Level 1
163 * @tc.require:
164 */
165 HWTEST_F(FilePermissionTest, PersistPermission_test_0001, testing::ext::TestSize.Level1)
166 {
167 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0001";
168 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
169 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
170 UriPolicyInfo infoB = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
171 std::vector<UriPolicyInfo> uriPolicies;
172 uriPolicies.emplace_back(infoA);
173 uriPolicies.emplace_back(infoB);
174 deque<struct PolicyErrorResult> errorResults;
175 vector<uint32_t> resultCodes;
176 resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
177 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
178 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
179 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
180 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
181 EXPECT_EQ(ret, EPERM);
182 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0001";
183 }
184 /**
185 * @tc.name: PersistPermission_test_0002
186 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
187 * @tc.size: MEDIUM
188 * @tc.type: FUNC
189 * @tc.level Level 1
190 * @tc.require:
191 */
192 HWTEST_F(FilePermissionTest, PersistPermission_test_0002, testing::ext::TestSize.Level1)
193 {
194 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0002";
195 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
196 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
197 std::vector<UriPolicyInfo> uriPolicies;
198 uriPolicies.emplace_back(infoA);
199 deque<struct PolicyErrorResult> errorResults;
200 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
201 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
202 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
203 EXPECT_EQ(ret, EPERM);
204 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0002";
205 }
206 /**
207 * @tc.name: ActivatePermission_test_0000
208 * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
209 * @tc.size: MEDIUM
210 * @tc.type: FUNC
211 * @tc.level Level 1
212 * @tc.require:
213 */
214 HWTEST_F(FilePermissionTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1)
215 {
216 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0000";
217 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
218 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
219 std::vector<UriPolicyInfo> uriPolicies;
220 uriPolicies.emplace_back(infoA);
221 deque<struct PolicyErrorResult> errorResults;
222 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
223 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
224 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
225 EXPECT_EQ(ret, EPERM);
226 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0000";
227 }
228 /**
229 * @tc.name: ActivatePermission_test_0001
230 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
231 * @tc.size: MEDIUM
232 * @tc.type: FUNC
233 * @tc.level Level 1
234 * @tc.require:
235 */
236 HWTEST_F(FilePermissionTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0001";
239 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
240 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
241 UriPolicyInfo infoB = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
242 std::vector<UriPolicyInfo> uriPolicies;
243 uriPolicies.emplace_back(infoA);
244 uriPolicies.emplace_back(infoB);
245 deque<struct PolicyErrorResult> errorResults;
246 vector<uint32_t> resultCodes;
247 resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
248 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
249 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
250 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
251 EXPECT_EQ(ret, EPERM);
252 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0001";
253 }
254 /**
255 * @tc.name: ActivatePermission_test_0002
256 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
257 * @tc.size: MEDIUM
258 * @tc.type: FUNC
259 * @tc.level Level 1
260 * @tc.require:
261 */
262 HWTEST_F(FilePermissionTest, ActivatePermission_test_0002, testing::ext::TestSize.Level1)
263 {
264 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0002";
265 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
266 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
267 std::vector<UriPolicyInfo> uriPolicies;
268 uriPolicies.emplace_back(infoA);
269 deque<struct PolicyErrorResult> errorResults;
270 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
271 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
272 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
273 EXPECT_EQ(ret, EPERM);
274 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0002";
275 }
276 /**
277 * @tc.name: DeactivatePermission_test_0000
278 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
279 * @tc.size: MEDIUM
280 * @tc.type: FUNC
281 * @tc.level Level 1
282 * @tc.require:
283 */
284 HWTEST_F(FilePermissionTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0000";
287 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
288 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
289 std::vector<UriPolicyInfo> uriPolicies;
290 uriPolicies.emplace_back(infoA);
291 deque<struct PolicyErrorResult> errorResults;
292 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
293 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
294 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
295 EXPECT_EQ(ret, EPERM);
296 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0000";
297 }
298 /**
299 * @tc.name: DeactivatePermission_test_0001
300 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
301 * @tc.size: MEDIUM
302 * @tc.type: FUNC
303 * @tc.level Level 1
304 * @tc.require:
305 */
306 HWTEST_F(FilePermissionTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1)
307 {
308 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0001";
309 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
310 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
311 UriPolicyInfo infoB = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
312 std::vector<UriPolicyInfo> uriPolicies;
313 uriPolicies.emplace_back(infoA);
314 uriPolicies.emplace_back(infoB);
315 deque<struct PolicyErrorResult> errorResults;
316 vector<uint32_t> resultCodes;
317 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
318 resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
319 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _))
320 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
321 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
322 EXPECT_EQ(ret, EPERM);
323 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0001";
324 }
325 /**
326 * @tc.name: DeactivatePermission_test_0002
327 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
328 * @tc.size: MEDIUM
329 * @tc.type: FUNC
330 * @tc.level Level 1
331 * @tc.require:
332 */
333 HWTEST_F(FilePermissionTest, DeactivatePermission_test_0002, testing::ext::TestSize.Level1)
334 {
335 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0002";
336 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
337 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
338 std::vector<UriPolicyInfo> uriPolicies;
339 uriPolicies.emplace_back(infoA);
340 deque<struct PolicyErrorResult> errorResults;
341 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
342 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
343 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
344 EXPECT_EQ(ret, EPERM);
345 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0002";
346 }
347 /**
348 * @tc.name: RevokePermission_test_0000
349 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
350 * @tc.size: MEDIUM
351 * @tc.type: FUNC
352 * @tc.level Level 1
353 * @tc.require:
354 */
355 HWTEST_F(FilePermissionTest, RevokePermission_test_0000, testing::ext::TestSize.Level1)
356 {
357 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_0000";
358 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
359 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
360 std::vector<UriPolicyInfo> uriPolicies;
361 uriPolicies.emplace_back(infoA);
362 deque<struct PolicyErrorResult> errorResults;
363 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
364 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
365 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
366 EXPECT_EQ(ret, EPERM);
367 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_0000";
368 }
369 /**
370 * @tc.name: RevokePermission_test_0001
371 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
372 * @tc.size: MEDIUM
373 * @tc.type: FUNC
374 * @tc.level Level 1
375 * @tc.require:
376 */
377 HWTEST_F(FilePermissionTest, RevokePermission_test_0001, testing::ext::TestSize.Level1)
378 {
379 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_0001";
380 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage", .mode = -1};
381 std::vector<UriPolicyInfo> uriPolicies;
382 uriPolicies.emplace_back(infoA);
383 deque<struct PolicyErrorResult> errorResults;
384 vector<uint32_t> resultCodes;
385 resultCodes.push_back(PolicyErrorCode::INVALID_MODE);
386 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
387 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _))
388 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
389 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
390 EXPECT_EQ(ret, EPERM);
391 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_0001";
392 }
393 /**
394 * @tc.name: RevokePermission_test_0002
395 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
396 * @tc.size: MEDIUM
397 * @tc.type: FUNC
398 * @tc.level Level 1
399 * @tc.require:
400 */
401 HWTEST_F(FilePermissionTest, RevokePermission_test_0002, testing::ext::TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_0002";
404 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/test01.test",
405 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
406 std::vector<UriPolicyInfo> uriPolicies;
407 uriPolicies.emplace_back(infoA);
408 deque<struct PolicyErrorResult> errorResults;
409 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
410 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
411 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
412 EXPECT_EQ(ret, EPERM);
413 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_0002";
414 }
415 /**
416 * @tc.name: GetPathByPermission_test_0001
417 * @tc.desc: Test function of GetPathByPermission() interface for SUCCESS.
418 * @tc.size: MEDIUM
419 * @tc.type: FUNC
420 * @tc.level Level 1
421 * @tc.require:
422 */
423 HWTEST_F(FilePermissionTest, GetPathByPermission_test_0001, testing::ext::TestSize.Level1)
424 {
425 GTEST_LOG_(INFO) << "FileShareTest-begin GetPathByPermission_test_0001";
426 std::string PermissionName = "ohos.permission.READ_WRITE_DOWNLOAD_DIRECTORY";
427 std::string sandboxPath = "/storage/Users/currentUser/Download";
428 std::string path = FilePermission::GetPathByPermission("", PermissionName);
429 EXPECT_EQ(path, sandboxPath);
430 GTEST_LOG_(INFO) << "FileShareTest-end GetPathByPermission_test_0001";
431 }
432 /**
433 * @tc.name: GetPathByPermission_test_0002
434 * @tc.desc: Test function of GetPathByPermission() interface for SUCCESS.
435 * @tc.size: MEDIUM
436 * @tc.type: FUNC
437 * @tc.level Level 1
438 * @tc.require:
439 */
440 HWTEST_F(FilePermissionTest, GetPathByPermission_test_0002, testing::ext::TestSize.Level1)
441 {
442 GTEST_LOG_(INFO) << "FileShareTest-begin GetPathByPermission_test_0002";
443 std::string PermissionName = "ohos.permission.READ_WRITE_DESKTOP_DIRECTORY";
444 std::string sandboxPath = "/storage/Users/currentUser/Desktop";
445 std::string path = FilePermission::GetPathByPermission("", PermissionName);
446 EXPECT_EQ(path, sandboxPath);
447 GTEST_LOG_(INFO) << "FileShareTest-end GetPathByPermission_test_0002";
448 }
449 /**
450 * @tc.name: GetPathByPermission_test_0003
451 * @tc.desc: Test function of GetPathByPermission() interface for SUCCESS.
452 * @tc.size: MEDIUM
453 * @tc.type: FUNC
454 * @tc.level Level 1
455 * @tc.require:
456 */
457 HWTEST_F(FilePermissionTest, GetPathByPermission_test_0003, testing::ext::TestSize.Level1)
458 {
459 GTEST_LOG_(INFO) << "FileShareTest-begin GetPathByPermission_test_0003";
460 std::string PermissionName = "ohos.permission.READ_WRITE_DOCUMENTS_DIRECTORY";
461 std::string sandboxPath = "/storage/Users/currentUser/Documents";
462 std::string path = FilePermission::GetPathByPermission("", PermissionName);
463 EXPECT_EQ(path, sandboxPath);
464 GTEST_LOG_(INFO) << "FileShareTest-end GetPathByPermission_test_0003";
465 }
466 /**
467 * @tc.name: CheckPersistentPermission_test_0001
468 * @tc.desc: Test function of CheckPersistentPermission() interface for SUCCESS.
469 * @tc.size: MEDIUM
470 * @tc.type: FUNC
471 * @tc.level Level 1
472 * @tc.require:
473 */
474 HWTEST_F(FilePermissionTest, CheckPersistentPermission_test_0001, testing::ext::TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "FileShareTest-begin CheckPersistentPermission_test_0001";
477 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
478 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
479 std::vector<UriPolicyInfo> uriPolicies;
480 uriPolicies.emplace_back(infoA);
481 vector<bool> errorResults;
482 EXPECT_CALL(*sandboxMock_, CheckPersistPolicy(_, _, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
483 int32_t ret = FilePermission::CheckPersistentPermission(uriPolicies, errorResults);
484 EXPECT_EQ(ret, 0);
485 GTEST_LOG_(INFO) << "FileShareTest-end CheckPersistentPermission_test_0001";
486 }
487 /**
488 * @tc.name: CheckPersistentPermission_test_0002
489 * @tc.desc: Test function of CheckPersistentPermission() interface for SUCCESS.
490 * @tc.size: MEDIUM
491 * @tc.type: FUNC
492 * @tc.level Level 1
493 * @tc.require:
494 */
495 HWTEST_F(FilePermissionTest, CheckPersistentPermission_test_0002, testing::ext::TestSize.Level1)
496 {
497 GTEST_LOG_(INFO) << "FileShareTest-begin CheckPersistentPermission_test_0002";
498 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage",
499 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
500 std::vector<UriPolicyInfo> uriPolicies;
501 uriPolicies.emplace_back(infoA);
502 deque<struct PolicyErrorResult> errorResults;
503 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
504 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
505 EXPECT_CALL(*sandboxMock_, CheckPersistPolicy(_, _, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
506 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
507 EXPECT_EQ(ret, EPERM);
508 vector<bool> errorResult;
509 ret = FilePermission::CheckPersistentPermission(uriPolicies, errorResult);
510 EXPECT_EQ(ret, 0);
511 GTEST_LOG_(INFO) << "FileShareTest-end CheckPersistentPermission_test_0002";
512 }
513 /**
514 * @tc.name: CheckPersistentPermission_test_0003
515 * @tc.desc: Test function of CheckPersistentPermission() interface for SUCCESS.
516 * @tc.size: MEDIUM
517 * @tc.type: FUNC
518 * @tc.level Level 1
519 * @tc.require:
520 */
521 HWTEST_F(FilePermissionTest, CheckPersistentPermission_test_0003, testing::ext::TestSize.Level1)
522 {
523 GTEST_LOG_(INFO) << "FileShareTest-begin CheckPersistentPermission_test_0003";
524 UriPolicyInfo infoA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/001.txt",
525 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
526 std::vector<UriPolicyInfo> uriPolicies;
527 uriPolicies.emplace_back(infoA);
528 vector<bool> errorResult;
529 EXPECT_CALL(*sandboxMock_, CheckPersistPolicy(_, _, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
530 int32_t ret = FilePermission::CheckPersistentPermission(uriPolicies, errorResult);
531 EXPECT_EQ(ret, 0);
532 GTEST_LOG_(INFO) << "FileShareTest-end CheckPersistentPermission_test_0003";
533 }
534
535 /**
536 * @tc.name: GetPathPolicyInfoFromUriPolicyInfo_test_0001
537 * @tc.desc: Test function of GetPathPolicyInfoFromUriPolicyInfo() interface for SUCCESS.
538 * @tc.size: MEDIUM
539 * @tc.type: FUNC
540 * @tc.level Level 1
541 * @tc.require:
542 */
543 HWTEST_F(FilePermissionTest, GetPathPolicyInfoFromUriPolicyInfo_test_0001, testing::ext::TestSize.Level1)
544 {
545 GTEST_LOG_(INFO) << "FileShareTest-begin GetPathPolicyInfoFromUriPolicyInfo_test_0001";
546 UriPolicyInfo infoB = {.uri = BUNDLE_NAME_A + "/storage/001.txt"};
547 UriPolicyInfo infoC = {.uri = "file://media/Photo/10/1.jpeg"};
548 UriPolicyInfo infoD = {.uri = "file://" + BUNDLE_NAME_A + "/storage/001.txt?networkid=5454541547878787878748748"};
549 UriPolicyInfo infoE = {.uri = "file://" + BUNDLE_NAME_A + "/storage"};
550 std::vector<UriPolicyInfo> uriPolicies;
551 uriPolicies.emplace_back(infoB);
552 uriPolicies.emplace_back(infoC);
553 uriPolicies.emplace_back(infoD);
554 uriPolicies.emplace_back(infoE);
555 vector<bool> errorResult;
556 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
557 auto pathPolicies = FilePermission::GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResult);
558 ASSERT_TRUE(errorResult.size() == 4);
559 EXPECT_EQ(errorResult[3], true);
560 GTEST_LOG_(INFO) << "FileShareTest-end GetPathPolicyInfoFromUriPolicyInfo_test_0001";
561 }
562
563 /**
564 * @tc.name: ParseErrorResults_test_0001
565 * @tc.desc: Test function of ParseErrorResults() interface for SUCCESS.
566 * @tc.size: MEDIUM
567 * @tc.type: FUNC
568 * @tc.level Level 1
569 * @tc.require:
570 */
571 HWTEST_F(FilePermissionTest, ParseErrorResults_test_0001, testing::ext::TestSize.Level1)
572 {
573 GTEST_LOG_(INFO) << "FileShareTest-begin ParseErrorResults_test_0001";
574 vector<bool> resultCodes;
575 vector<bool> errorResults;
576 FilePermission::ParseErrorResults(resultCodes, errorResults);
577 EXPECT_EQ(errorResults.size(), 0);
578
579 resultCodes.push_back(false);
580 FilePermission::ParseErrorResults(resultCodes, errorResults);
581 EXPECT_EQ(errorResults.size(), 0);
582
583 resultCodes.push_back(false);
584 errorResults.push_back(true);
585 FilePermission::ParseErrorResults(resultCodes, errorResults);
586 ASSERT_TRUE(errorResults.size() == 1);
587 EXPECT_EQ(errorResults[0], false);
588
589 errorResults.push_back(true);
590 errorResults.push_back(true);
591 FilePermission::ParseErrorResults(resultCodes, errorResults);
592 ASSERT_TRUE(errorResults.size() == 3);
593 EXPECT_EQ(errorResults[0], false);
594 EXPECT_EQ(errorResults[1], false);
595 EXPECT_EQ(errorResults[2], false);
596 GTEST_LOG_(INFO) << "FileShareTest-end ParseErrorResults_test_0001";
597 }
598
599 /**
600 * @tc.name: ParseErrorResults_test_002
601 * @tc.desc: Test function of ParseErrorResults() interface for SUCCESS.
602 * @tc.size: MEDIUM
603 * @tc.type: FUNC
604 * @tc.level Level 1
605 * @tc.require:
606 */
607 HWTEST_F(FilePermissionTest, ParseErrorResults_test_002, testing::ext::TestSize.Level1)
608 {
609 GTEST_LOG_(INFO) << "FileShareTest-begin ParseErrorResults_test_002";
610 PolicyInfo infoA = {.path = "file://" + BUNDLE_NAME_A + "/storage/001.txt"};
611 PolicyInfo infoB = {.path = BUNDLE_NAME_A + "/storage/001.txt"};
612 PolicyInfo infoC = {.path = "file://media/Photo/10/1.jpeg"};
613 PolicyInfo infoD = {.path = "file://" + BUNDLE_NAME_A + "/storage/001.txt?networkid=5454541547878787878748748"};
614 PolicyInfo infoE = {.path = "file://" + BUNDLE_NAME_A + "/storage"};
615 std::vector<PolicyInfo> uriPolicies;
616 uriPolicies.emplace_back(infoA);
617 uriPolicies.emplace_back(infoB);
618 uriPolicies.emplace_back(infoC);
619 uriPolicies.emplace_back(infoD);
620 uriPolicies.emplace_back(infoE);
621 vector<uint32_t> resultCodes;
622 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN));
623 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
624 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_PATH));
625 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::PERMISSION_NOT_PERSISTED));
626
627 deque<struct PolicyErrorResult> errorResults;
628 FilePermission::ParseErrorResults(resultCodes, uriPolicies, errorResults);
629 ASSERT_TRUE(errorResults.size() == 0);
630
631 resultCodes.emplace_back(5);
632 FilePermission::ParseErrorResults(resultCodes, uriPolicies, errorResults);
633 ASSERT_TRUE(errorResults.size() == 4);
634 EXPECT_EQ(errorResults[0].uri, infoA.path);
635 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::PERSISTENCE_FORBIDDEN);
636 EXPECT_EQ(errorResults[1].uri, infoB.path);
637 EXPECT_EQ(errorResults[1].code, PolicyErrorCode::INVALID_MODE);
638 EXPECT_EQ(errorResults[2].uri, infoC.path);
639 EXPECT_EQ(errorResults[2].code, PolicyErrorCode::INVALID_PATH);
640 EXPECT_EQ(errorResults[3].uri, infoD.path);
641 EXPECT_EQ(errorResults[3].code, PolicyErrorCode::PERMISSION_NOT_PERSISTED);
642 GTEST_LOG_(INFO) << "FileShareTest-end ParseErrorResults_test_002";
643 }
644 /**
645 * @tc.name: PersistPermission_test_1000
646 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
647 * @tc.size: MEDIUM
648 * @tc.type: FUNC
649 * @tc.level Level 1
650 * @tc.require:
651 */
652 HWTEST_F(FilePermissionTest, PersistPermission_test_1000, testing::ext::TestSize.Level1)
653 {
654 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_1000";
655 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
656 .mode = OperationMode::READ_MODE};
657 std::vector<UriPolicyInfo> uriPolicies;
658 uriPolicies.emplace_back(infoTestA);
659 deque<struct PolicyErrorResult> errorResults;
660 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
661 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
662 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
663 EXPECT_EQ(ret, EPERM);
664 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_1000";
665 }
666 /**
667 * @tc.name: PersistPermission_test_1001
668 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
669 * @tc.size: MEDIUM
670 * @tc.type: FUNC
671 * @tc.level Level 1
672 * @tc.require:
673 */
674 HWTEST_F(FilePermissionTest, PersistPermission_test_1001, testing::ext::TestSize.Level1)
675 {
676 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_1001";
677 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
678 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
679 std::vector<UriPolicyInfo> uriPolicies;
680 uriPolicies.emplace_back(infoTestA);
681 deque<struct PolicyErrorResult> errorResults;
682 vector<uint32_t> resultCodes;
683 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_PATH));
684 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
685 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
686 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
687 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
688 EXPECT_EQ(ret, EPERM);
689 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_PATH);
690 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_1001";
691 }
692
693 /**
694 * @tc.name: PersistPermission_test_1002
695 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
696 * @tc.size: MEDIUM
697 * @tc.type: FUNC
698 * @tc.level Level 1
699 * @tc.require:
700 */
701 HWTEST_F(FilePermissionTest, PersistPermission_test_1002, testing::ext::TestSize.Level1)
702 {
703 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_1002";
704 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt", .mode = 5};
705 std::vector<UriPolicyInfo> uriPolicies;
706 uriPolicies.emplace_back(infoTestA);
707 deque<struct PolicyErrorResult> errorResults;
708 vector<uint32_t> resultCodes;
709 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
710 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
711 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
712 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
713 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
714 EXPECT_EQ(ret, EPERM);
715 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
716 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_1002";
717 }
718
719 /**
720 * @tc.name: PersistPermission_test_1003
721 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
722 * @tc.size: MEDIUM
723 * @tc.type: FUNC
724 * @tc.level Level 1
725 * @tc.require:
726 */
727 HWTEST_F(FilePermissionTest, PersistPermission_test_1003, testing::ext::TestSize.Level1)
728 {
729 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_1003";
730 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
731 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
732 std::vector<UriPolicyInfo> uriPolicies;
733 uriPolicies.emplace_back(infoTestA);
734 deque<struct PolicyErrorResult> errorResults;
735 vector<uint32_t> resultCodes;
736 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN));
737 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
738 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
739 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
740 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
741 EXPECT_EQ(ret, EPERM);
742 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::PERSISTENCE_FORBIDDEN);
743 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_1003";
744 }
745
746 /**
747 * @tc.name: PersistPermission_test_1004
748 * @tc.desc: Test function of PersistPermission() interface for SUCCESS.
749 * @tc.size: MEDIUM
750 * @tc.type: FUNC
751 * @tc.level Level 1
752 * @tc.require:
753 */
754 HWTEST_F(FilePermissionTest, PersistPermission_test_1004, testing::ext::TestSize.Level1)
755 {
756 GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_1004";
757 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
758 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
759 std::vector<UriPolicyInfo> uriPolicies;
760 uriPolicies.emplace_back(infoTestA);
761 deque<struct PolicyErrorResult> errorResults;
762 vector<uint32_t> resultCodes;
763 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
764 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
765 EXPECT_CALL(*sandboxMock_, PersistPolicy(_, _))
766 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
767 int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults);
768 EXPECT_EQ(ret, EPERM);
769 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
770 GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_1004";
771 }
772
773 /**
774 * @tc.name: ActivatePermission_test_1000
775 * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
776 * @tc.size: MEDIUM
777 * @tc.type: FUNC
778 * @tc.level Level 1
779 * @tc.require:
780 */
781 HWTEST_F(FilePermissionTest, ActivatePermission_test_1000, testing::ext::TestSize.Level1)
782 {
783 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_1000";
784 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
785 .mode = OperationMode::READ_MODE};
786 std::vector<UriPolicyInfo> uriPolicies;
787 uriPolicies.emplace_back(infoTestA);
788 deque<struct PolicyErrorResult> errorResults;
789 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
790 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
791 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
792 EXPECT_EQ(ret, EPERM);
793 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_1000";
794 }
795 /**
796 * @tc.name: ActivatePermission_test_1001
797 * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
798 * @tc.size: MEDIUM
799 * @tc.type: FUNC
800 * @tc.level Level 1
801 * @tc.require:
802 */
803 HWTEST_F(FilePermissionTest, ActivatePermission_test_1001, testing::ext::TestSize.Level1)
804 {
805 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_1001";
806 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
807 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
808 std::vector<UriPolicyInfo> uriPolicies;
809 uriPolicies.emplace_back(infoTestA);
810 deque<struct PolicyErrorResult> errorResults;
811 vector<uint32_t> resultCodes;
812 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_PATH));
813 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
814 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
815 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
816 EXPECT_EQ(ret, EPERM);
817 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_PATH);
818 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_1001";
819 }
820
821 /**
822 * @tc.name: ActivatePermission_test_1002
823 * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
824 * @tc.size: MEDIUM
825 * @tc.type: FUNC
826 * @tc.level Level 1
827 * @tc.require:
828 */
829 HWTEST_F(FilePermissionTest, ActivatePermission_test_1002, testing::ext::TestSize.Level1)
830 {
831 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_1002";
832 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt", .mode = 5};
833 std::vector<UriPolicyInfo> uriPolicies;
834 uriPolicies.emplace_back(infoTestA);
835 deque<struct PolicyErrorResult> errorResults;
836 vector<uint32_t> resultCodes;
837 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
838 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
839 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
840 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
841 EXPECT_EQ(ret, EPERM);
842 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
843 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_1002";
844 }
845
846 /**
847 * @tc.name: ActivatePermission_test_1003
848 * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
849 * @tc.size: MEDIUM
850 * @tc.type: FUNC
851 * @tc.level Level 1
852 * @tc.require:
853 */
854 HWTEST_F(FilePermissionTest, ActivatePermission_test_1003, testing::ext::TestSize.Level1)
855 {
856 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_1003";
857 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
858 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
859 std::vector<UriPolicyInfo> uriPolicies;
860 uriPolicies.emplace_back(infoTestA);
861 deque<struct PolicyErrorResult> errorResults;
862 vector<uint32_t> resultCodes;
863 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN));
864 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
865 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
866 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
867 EXPECT_EQ(ret, EPERM);
868 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::PERSISTENCE_FORBIDDEN);
869 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_1003";
870 }
871
872 /**
873 * @tc.name: ActivatePermission_test_1004
874 * @tc.desc: Test function of ActivatePermission() interface for SUCCESS.
875 * @tc.size: MEDIUM
876 * @tc.type: FUNC
877 * @tc.level Level 1
878 * @tc.require:
879 */
880 HWTEST_F(FilePermissionTest, ActivatePermission_test_1004, testing::ext::TestSize.Level1)
881 {
882 GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_1004";
883 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
884 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
885 std::vector<UriPolicyInfo> uriPolicies;
886 uriPolicies.emplace_back(infoTestA);
887 deque<struct PolicyErrorResult> errorResults;
888 vector<uint32_t> resultCodes;
889 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
890 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
891 EXPECT_CALL(*upmsMock_, Active(_, _)).WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
892 int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults);
893 EXPECT_EQ(ret, EPERM);
894 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
895 GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_1004";
896 }
897
898 /**
899 * @tc.name: DeactivatePermission_test_1000
900 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
901 * @tc.size: MEDIUM
902 * @tc.type: FUNC
903 * @tc.level Level 1
904 * @tc.require:
905 */
906 HWTEST_F(FilePermissionTest, DeactivatePermission_test_1000, testing::ext::TestSize.Level1)
907 {
908 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_1000";
909 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
910 .mode = OperationMode::READ_MODE};
911 std::vector<UriPolicyInfo> uriPolicies;
912 uriPolicies.emplace_back(infoTestA);
913 deque<struct PolicyErrorResult> errorResults;
914 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
915 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
916 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
917 EXPECT_EQ(ret, EPERM);
918 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_1000";
919 }
920 /**
921 * @tc.name: DeactivatePermission_test_1001
922 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
923 * @tc.size: MEDIUM
924 * @tc.type: FUNC
925 * @tc.level Level 1
926 * @tc.require:
927 */
928 HWTEST_F(FilePermissionTest, DeactivatePermission_test_1001, testing::ext::TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_1001";
931 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
932 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
933 std::vector<UriPolicyInfo> uriPolicies;
934 uriPolicies.emplace_back(infoTestA);
935 deque<struct PolicyErrorResult> errorResults;
936 vector<uint32_t> resultCodes;
937 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_PATH));
938 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
939 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _))
940 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
941 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
942 EXPECT_EQ(ret, EPERM);
943 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_PATH);
944 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_1001";
945 }
946
947 /**
948 * @tc.name: DeactivatePermission_test_1002
949 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
950 * @tc.size: MEDIUM
951 * @tc.type: FUNC
952 * @tc.level Level 1
953 * @tc.require:
954 */
955 HWTEST_F(FilePermissionTest, DeactivatePermission_test_1002, testing::ext::TestSize.Level1)
956 {
957 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_1002";
958 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt", .mode = 5};
959 std::vector<UriPolicyInfo> uriPolicies;
960 uriPolicies.emplace_back(infoTestA);
961 deque<struct PolicyErrorResult> errorResults;
962 vector<uint32_t> resultCodes;
963 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
964 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
965 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _))
966 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
967 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
968 EXPECT_EQ(ret, EPERM);
969 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
970 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_1002";
971 }
972
973 /**
974 * @tc.name: DeactivatePermission_test_1003
975 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
976 * @tc.size: MEDIUM
977 * @tc.type: FUNC
978 * @tc.level Level 1
979 * @tc.require:
980 */
981 HWTEST_F(FilePermissionTest, DeactivatePermission_test_1003, testing::ext::TestSize.Level1)
982 {
983 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_1003";
984 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
985 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
986 std::vector<UriPolicyInfo> uriPolicies;
987 uriPolicies.emplace_back(infoTestA);
988 deque<struct PolicyErrorResult> errorResults;
989 vector<uint32_t> resultCodes;
990 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN));
991 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
992 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _))
993 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
994 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
995 EXPECT_EQ(ret, EPERM);
996 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::PERSISTENCE_FORBIDDEN);
997 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_1003";
998 }
999
1000 /**
1001 * @tc.name: DeactivatePermission_test_1004
1002 * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS.
1003 * @tc.size: MEDIUM
1004 * @tc.type: FUNC
1005 * @tc.level Level 1
1006 * @tc.require:
1007 */
1008 HWTEST_F(FilePermissionTest, DeactivatePermission_test_1004, testing::ext::TestSize.Level1)
1009 {
1010 GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_1004";
1011 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
1012 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
1013 std::vector<UriPolicyInfo> uriPolicies;
1014 uriPolicies.emplace_back(infoTestA);
1015 deque<struct PolicyErrorResult> errorResults;
1016 vector<uint32_t> resultCodes;
1017 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
1018 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
1019 EXPECT_CALL(*sandboxMock_, StopAccessingPolicy(_, _))
1020 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
1021 int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults);
1022 EXPECT_EQ(ret, EPERM);
1023 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
1024 GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_1004";
1025 }
1026
1027 /**
1028 * @tc.name: RevokePermission_test_1000
1029 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
1030 * @tc.size: MEDIUM
1031 * @tc.type: FUNC
1032 * @tc.level Level 1
1033 * @tc.require:
1034 */
1035 HWTEST_F(FilePermissionTest, RevokePermission_test_1000, testing::ext::TestSize.Level1)
1036 {
1037 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_1000";
1038 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
1039 .mode = OperationMode::READ_MODE};
1040 std::vector<UriPolicyInfo> uriPolicies;
1041 uriPolicies.emplace_back(infoTestA);
1042 deque<struct PolicyErrorResult> errorResults;
1043 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
1044 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
1045 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
1046 EXPECT_EQ(ret, EPERM);
1047 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_1000";
1048 }
1049 /**
1050 * @tc.name: RevokePermission_test_1001
1051 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
1052 * @tc.size: MEDIUM
1053 * @tc.type: FUNC
1054 * @tc.level Level 1
1055 * @tc.require:
1056 */
1057 HWTEST_F(FilePermissionTest, RevokePermission_test_1001, testing::ext::TestSize.Level1)
1058 {
1059 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_1001";
1060 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
1061 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
1062 std::vector<UriPolicyInfo> uriPolicies;
1063 uriPolicies.emplace_back(infoTestA);
1064 deque<struct PolicyErrorResult> errorResults;
1065 vector<uint32_t> resultCodes;
1066 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_PATH));
1067 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
1068 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _))
1069 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
1070 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
1071 EXPECT_EQ(ret, EPERM);
1072 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_PATH);
1073 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_1001";
1074 }
1075
1076 /**
1077 * @tc.name: RevokePermission_test_1002
1078 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
1079 * @tc.size: MEDIUM
1080 * @tc.type: FUNC
1081 * @tc.level Level 1
1082 * @tc.require:
1083 */
1084 HWTEST_F(FilePermissionTest, RevokePermission_test_1002, testing::ext::TestSize.Level1)
1085 {
1086 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_1002";
1087 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt", .mode = 5};
1088 std::vector<UriPolicyInfo> uriPolicies;
1089 uriPolicies.emplace_back(infoTestA);
1090 deque<struct PolicyErrorResult> errorResults;
1091 vector<uint32_t> resultCodes;
1092 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
1093 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
1094 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _))
1095 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
1096 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
1097 EXPECT_EQ(ret, EPERM);
1098 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
1099 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_1002";
1100 }
1101
1102 /**
1103 * @tc.name: RevokePermission_test_1003
1104 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
1105 * @tc.size: MEDIUM
1106 * @tc.type: FUNC
1107 * @tc.level Level 1
1108 * @tc.require:
1109 */
1110 HWTEST_F(FilePermissionTest, RevokePermission_test_1003, testing::ext::TestSize.Level1)
1111 {
1112 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_1003";
1113 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
1114 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
1115 std::vector<UriPolicyInfo> uriPolicies;
1116 uriPolicies.emplace_back(infoTestA);
1117 deque<struct PolicyErrorResult> errorResults;
1118 vector<uint32_t> resultCodes;
1119 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::PERSISTENCE_FORBIDDEN));
1120 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
1121 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _))
1122 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
1123 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
1124 EXPECT_EQ(ret, EPERM);
1125 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::PERSISTENCE_FORBIDDEN);
1126 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_1003";
1127 }
1128
1129 /**
1130 * @tc.name: RevokePermission_test_1004
1131 * @tc.desc: Test function of RevokePermission() interface for SUCCESS.
1132 * @tc.size: MEDIUM
1133 * @tc.type: FUNC
1134 * @tc.level Level 1
1135 * @tc.require:
1136 */
1137 HWTEST_F(FilePermissionTest, RevokePermission_test_1004, testing::ext::TestSize.Level1)
1138 {
1139 GTEST_LOG_(INFO) << "FileShareTest-begin RevokePermission_test_1004";
1140 UriPolicyInfo infoTestA = {.uri = "file://" + BUNDLE_NAME_A + "/storage/PersistPermission01.txt",
1141 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
1142 std::vector<UriPolicyInfo> uriPolicies;
1143 uriPolicies.emplace_back(infoTestA);
1144 deque<struct PolicyErrorResult> errorResults;
1145 vector<uint32_t> resultCodes;
1146 resultCodes.emplace_back(static_cast<uint32_t>(PolicyErrorCode::INVALID_MODE));
1147 EXPECT_CALL(*funcMock, access(_, _)).WillRepeatedly(Return(0));
1148 EXPECT_CALL(*sandboxMock_, UnPersistPolicy(_, _))
1149 .WillOnce(DoAll(SetArgReferee<1>(resultCodes), Return(SANDBOX_MANAGER_OK)));
1150 int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults);
1151 EXPECT_EQ(ret, EPERM);
1152 EXPECT_EQ(errorResults[0].code, PolicyErrorCode::INVALID_MODE);
1153 GTEST_LOG_(INFO) << "FileShareTest-end RevokePermission_test_1004";
1154 }
1155
1156 /**
1157 * @tc.name: CheckPathPermission_test_1000
1158 * @tc.desc: Test function of CheckPathPermission() interface for SUCCESS.
1159 * @tc.size: MEDIUM
1160 * @tc.type: FUNC
1161 * @tc.level Level 1
1162 * @tc.require:
1163 */
1164 HWTEST_F(FilePermissionTest, CheckPathPermission_test_1000, testing::ext::TestSize.Level1)
1165 {
1166 GTEST_LOG_(INFO) << "FileShareTest-begin CheckPathPermission_test_1000";
1167 PathPolicyInfo infoTestA = {.path = "/storage/Users/currentUser/Documents/1.txt",
1168 .mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE};
1169 std::vector<PathPolicyInfo> pathPolicies;
1170 pathPolicies.emplace_back(infoTestA);
1171 vector<bool> errorResults;
1172 EXPECT_CALL(*sandboxMock_, CheckPersistPolicy(_, _, _)).WillOnce(Return(SANDBOX_MANAGER_OK));
1173 uint32_t tokenId = 537688848;
1174 int32_t policyType = PERSISTENT_TYPE;
1175 int32_t ret = FilePermission::CheckPathPermission(tokenId, pathPolicies, policyType, errorResults);
1176 EXPECT_EQ(ret, 0);
1177
1178 ret = FilePermission::CheckPathPermission(tokenId, pathPolicies, 2, errorResults);
1179 EXPECT_EQ(ret, 401);
1180 GTEST_LOG_(INFO) << "FileShareTest-end CheckPathPermission_test_1000";
1181 }
1182 #endif
1183 } // namespace AppFileService
1184 } // namespace OHOS