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