1 /*
2 * Copyright (c) 2023-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 <gtest/gtest.h>
16
17 #define private public
18 #include "uri_permission_manager_client.h"
19 #include "uri_permission_load_callback.h"
20 #undef private
21 #include "ability_manager_errors.h"
22 #include "mock_sa_call.h"
23 #include "want.h"
24 using namespace testing;
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace AAFwk {
28 class UriPermissionManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
SetUpTestCase()36 void UriPermissionManagerTest::SetUpTestCase() {}
37
TearDownTestCase()38 void UriPermissionManagerTest::TearDownTestCase() {}
39
SetUp()40 void UriPermissionManagerTest::SetUp() {}
41
TearDown()42 void UriPermissionManagerTest::TearDown() {}
43
44 /*
45 * Feature: UriPermissionManagerClient
46 * Function: ConnectUriPermService
47 * SubFunction: NA
48 * FunctionPoints: UriPermissionManagerClient ConnectUriPermService
49 */
50 HWTEST_F(UriPermissionManagerTest, ConnectUriPermService_001, TestSize.Level1)
51 {
52 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
53 upmc.saLoadFinished_ = true;
54 EXPECT_EQ(upmc.GetUriPermMgr(), nullptr);
55 auto ret = upmc.ConnectUriPermService();
56 }
57
58 /*
59 * Feature: UriPermissionManagerClient
60 * Function: ConnectUriPermService
61 * SubFunction: NA
62 * FunctionPoints: UriPermissionManagerClient ConnectUriPermService
63 */
64 HWTEST_F(UriPermissionManagerTest, ConnectUriPermService_002, TestSize.Level1)
65 {
66 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
67 sptr<IRemoteObject> remoteObject = new (std::nothrow) UriPermissionLoadCallback();
68 upmc.SetUriPermMgr(remoteObject);
69 EXPECT_EQ(upmc.GetUriPermMgr(), nullptr);
70 auto ret = upmc.ConnectUriPermService();
71 }
72
73 /*
74 * Feature: UriPermissionManagerClient
75 * Function: ConnectUriPermService
76 * SubFunction: NA
77 * FunctionPoints: UriPermissionManagerClient ConnectUriPermService
78 */
79 HWTEST_F(UriPermissionManagerTest, ConnectUriPermService_003, TestSize.Level1)
80 {
81 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
82 sptr<IRemoteObject> remoteObject = nullptr;
83 upmc.SetUriPermMgr(remoteObject);
84 EXPECT_EQ(upmc.GetUriPermMgr(), nullptr);
85 auto ret = upmc.ConnectUriPermService();
86 }
87
88 /*
89 * Feature: UriPermissionManagerClient
90 * Function: LoadUriPermService
91 * SubFunction: NA
92 * FunctionPoints: UriPermissionManagerClient LoadUriPermService
93 */
94 HWTEST_F(UriPermissionManagerTest, LoadUriPermService_001, TestSize.Level1)
95 {
96 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
97 upmc.saLoadFinished_ = true;
98 auto ret = upmc.LoadUriPermService();
99 EXPECT_TRUE(ret);
100 }
101
102 /*
103 * Feature: UriPermissionManagerClient
104 * Function: GrantUriPermission
105 * SubFunction: SingleGrantUriPermission
106 * FunctionPoints: NA.
107 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
108 */
109 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermission_001, TestSize.Level1)
110 {
111 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
112 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
113 std::string bundleName = "com.example.test1001";
114 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
115 auto ret = upmc.GrantUriPermission(uri, flag, bundleName, 0, 0);
116 EXPECT_NE(ret, ERR_OK);
117 }
118
119 /*
120 * Feature: UriPermissionManagerClient
121 * Function: GrantUriPermission
122 * SubFunction: BatchGrantUriPermission
123 * FunctionPoints: Size of uris is 0
124 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
125 */
126 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_BatchGrantUriPermission_001, TestSize.Level1)
127 {
128 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
129 std::vector<Uri> uriVec;
130 std::string bundleName = "com.example.test1001";
131 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
132 auto ret = upmc.GrantUriPermission(uriVec, flag, bundleName, 0, 0);
133 EXPECT_EQ(ret, ERR_URI_LIST_OUT_OF_RANGE);
134 }
135
136 /*
137 * Feature: UriPermissionManagerClient
138 * Function: GrantUriPermission
139 * SubFunction: BatchGrantUriPermission
140 * FunctionPoints: Size of uris is more than 500
141 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
142 */
143 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_BatchGrantUriPermission_002, TestSize.Level1)
144 {
145 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
146 Uri uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
147 std::vector<Uri> uriVec(501, uri);
148 std::string bundleName = "com.example.test1001";
149 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
150 auto ret = upmc.GrantUriPermission(uriVec, flag, bundleName, 0, 0);
151 EXPECT_EQ(ret, ERR_URI_LIST_OUT_OF_RANGE);
152 }
153
154 /*
155 * Feature: UriPermissionManagerClient
156 * Function: GrantUriPermission
157 * SubFunction: BatchGrantUriPermission
158 * FunctionPoints: Size of uris is betweent 1 and 500
159 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
160 */
161 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_BatchGrantUriPermission_003, TestSize.Level1)
162 {
163 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
164 Uri uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
165 std::vector<Uri> uriVec(500, uri);
166 std::string bundleName = "com.example.test1001";
167 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
168 auto ret = upmc.GrantUriPermission(uriVec, flag, bundleName, 0, 0);
169 EXPECT_NE(ret, ERR_OK);
170 }
171
172 /*
173 * Feature: UriPermissionManagerClient
174 * Function: RevokeUriPermissionManually
175 * SubFunction: RevokeUriPermissionManually
176 * FunctionPoints: Uri is invalid.
177 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermissionManually
178 */
179 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermissionManually_001, TestSize.Level1)
180 {
181 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
182 auto uri = Uri("http://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
183 std::string bundleName = "com.example.test1001";
184 auto ret = upmc.RevokeUriPermissionManually(uri, bundleName);
185 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
186 }
187
188 /*
189 * Feature: UriPermissionManagerClient
190 * Function: RevokeUriPermissionManually
191 * SubFunction: RevokeUriPermissionManually
192 * FunctionPoints: Uri is valid.
193 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermissionManually
194 */
195 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermissionManually_002, TestSize.Level1)
196 {
197 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
198 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
199 std::string bundleName = "com.example.test1001";
200 auto ret = upmc.RevokeUriPermissionManually(uri, bundleName);
201 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
202 }
203
204 /*
205 * Feature: UriPermissionManagerClient
206 * Function: RevokeUriPermissionManually
207 * SubFunction: RevokeUriPermissionManually
208 * FunctionPoints: Uri is valid.
209 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermissionManually
210 */
211 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermissionManually_003, TestSize.Level1)
212 {
213 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
214 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
215 std::string bundleName = "com.example.test1001";
216 auto ret = upmc.RevokeUriPermissionManually(uri, bundleName, 1001);
217 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
218 }
219
220 /*
221 * Feature: UriPermissionManagerClient
222 * Function: RevokeUriPermission
223 * SubFunction: RevokeUriPermission
224 * FunctionPoints: NA
225 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermission
226 */
227 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermission_001, TestSize.Level1)
228 {
229 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
230 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
231 uint32_t targetTokenId = 1001;
232 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
233 upmc.RevokeUriPermission(targetTokenId);
234 bool ret = upmc.VerifyUriPermission(uri, flag, targetTokenId);
235 EXPECT_EQ(ret, false);
236 }
237
238 /*
239 * Feature: UriPermissionManagerClient
240 * Function: RevokeAllUriPermissions
241 * SubFunction: RevokeAllUriPermissions
242 * FunctionPoints: NA
243 * CaseDescription: Verify UriPermissionManagerClient RevokeAllUriPermissions
244 */
245 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeAllUriPermissions_001, TestSize.Level1)
246 {
247 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
248 uint32_t targetTokenId = 1001;
249 auto ret = upmc.RevokeAllUriPermissions(targetTokenId);
250 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
251 }
252
253 /*
254 * Feature: UriPermissionManagerClient
255 * Function: VerifyUriPermission
256 * SubFunction: VerifyUriPermission
257 * FunctionPoints: NA
258 * CaseDescription: Verify UriPermissionManagerClient VerifyUriPermission
259 */
260 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_VerifyUriPermission_001, TestSize.Level1)
261 {
262 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
263 auto uriStr = "file://docs/storage/Users/currentUser/test.txt";
264 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
265 std::string bundleName = "com.example.test";
266 uint32_t targetTokenId = 100002;
267 Uri uri(uriStr);
268 bool res = upmc.VerifyUriPermission(uri, flag, targetTokenId);
269 EXPECT_EQ(res, false);
270 }
271
272 /*
273 * Feature: UriPermissionManagerClient
274 * Function: CheckUriAuthorization
275 * SubFunction: CheckUriAuthorization
276 * FunctionPoints: Size of uris is 0
277 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
278 */
279 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_001, TestSize.Level1)
280 {
281 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
282 std::vector<std::string> uriVec;
283 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
284 uint32_t tokenId = 1001;
285 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
286 std::vector<bool> expectRes;
287 EXPECT_EQ(res, expectRes);
288 }
289
290 /*
291 * Feature: UriPermissionManagerClient
292 * Function: CheckUriAuthorization
293 * SubFunction: CheckUriAuthorization
294 * FunctionPoints: Size of uris is between 1 and 500
295 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
296 */
297 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_002, TestSize.Level1)
298 {
299 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
300 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
301 std::vector<std::string> uriVec(1, uriStr);
302 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
303 uint32_t tokenId = 1001;
304 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
305 std::vector<bool> expectRes(1, false);
306 EXPECT_EQ(res, expectRes);
307 }
308
309 /*
310 * Feature: UriPermissionManagerClient
311 * Function: CheckUriAuthorization
312 * SubFunction: CheckUriAuthorization
313 * FunctionPoints: Size of uris is more than 500
314 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
315 */
316 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_003, TestSize.Level1)
317 {
318 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
319 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
320 std::vector<std::string> uriVec(501, uriStr);
321 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
322 uint32_t tokenId = 1001;
323 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
324 std::vector<bool> expectRes(501, false);
325 EXPECT_EQ(res, expectRes);
326 }
327
328 /*
329 * Feature: UriPermissionManagerClient
330 * Function: GrantUriPermissionPrivileged
331 * SubFunction: GrantUriPermissionPrivileged
332 * FunctionPoints: Size of uris is 0
333 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
334 */
335 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_001, TestSize.Level1)
336 {
337 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
338 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
339 std::vector<Uri> uriVec;
340 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
341 std::string bundleName = "com.example.test1001";
342 int32_t appIndex = 0;
343 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, -1);
344 EXPECT_EQ(res, ERR_URI_LIST_OUT_OF_RANGE);
345 }
346
347 /*
348 * Feature: UriPermissionManagerClient
349 * Function: GrantUriPermissionPrivileged
350 * SubFunction: GrantUriPermissionPrivileged
351 * FunctionPoints: Size of uris is more than 500
352 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
353 */
354 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_002, TestSize.Level1)
355 {
356 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
357 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
358 std::vector<Uri> uriVec(501, Uri(uriStr));
359 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
360 std::string bundleName = "com.example.test1001";
361 int32_t appIndex = 0;
362 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, -1);
363 EXPECT_EQ(res, ERR_URI_LIST_OUT_OF_RANGE);
364 }
365
366 /*
367 * Feature: UriPermissionManagerClient
368 * Function: GrantUriPermissionPrivileged
369 * SubFunction: GrantUriPermissionPrivileged
370 * FunctionPoints: size of uri is between 1 and 500
371 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
372 */
373 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_003, TestSize.Level1)
374 {
375 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
376 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
377 std::vector<Uri> uriVec(1, Uri(uriStr));
378 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
379 std::string bundleName = "com.example.test1001";
380 int32_t appIndex = 0;
381 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, -1);
382 EXPECT_EQ(res, CHECK_PERMISSION_FAILED);
383 }
384 } // namespace AAFwk
385 } // namespace OHOS