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: RevokeAllUriPermissions
223 * SubFunction: RevokeAllUriPermissions
224 * FunctionPoints: NA
225 * CaseDescription: Verify UriPermissionManagerClient RevokeAllUriPermissions
226 */
227 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeAllUriPermissions_001, TestSize.Level1)
228 {
229 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
230 uint32_t targetTokenId = 1001;
231 auto ret = upmc.RevokeAllUriPermissions(targetTokenId);
232 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
233 }
234
235 /*
236 * Feature: UriPermissionManagerClient
237 * Function: VerifyUriPermission
238 * SubFunction: VerifyUriPermission
239 * FunctionPoints: NA
240 * CaseDescription: Verify UriPermissionManagerClient VerifyUriPermission
241 */
242 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_VerifyUriPermission_001, TestSize.Level1)
243 {
244 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
245 auto uriStr = "file://docs/storage/Users/currentUser/test.txt";
246 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
247 std::string bundleName = "com.example.test";
248 uint32_t targetTokenId = 100002;
249 Uri uri(uriStr);
250 bool res = upmc.VerifyUriPermission(uri, flag, targetTokenId);
251 EXPECT_EQ(res, false);
252 }
253
254 /*
255 * Feature: UriPermissionManagerClient
256 * Function: CheckUriAuthorization
257 * SubFunction: CheckUriAuthorization
258 * FunctionPoints: Size of uris is 0
259 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
260 */
261 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_001, TestSize.Level1)
262 {
263 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
264 std::vector<std::string> uriVec;
265 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
266 uint32_t tokenId = 1001;
267 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
268 std::vector<bool> expectRes;
269 EXPECT_EQ(res, expectRes);
270 }
271
272 /*
273 * Feature: UriPermissionManagerClient
274 * Function: CheckUriAuthorization
275 * SubFunction: CheckUriAuthorization
276 * FunctionPoints: Size of uris is between 1 and 500
277 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
278 */
279 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_002, TestSize.Level1)
280 {
281 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
282 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
283 std::vector<std::string> uriVec(1, uriStr);
284 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
285 uint32_t tokenId = 1001;
286 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
287 std::vector<bool> expectRes(1, false);
288 EXPECT_EQ(res, expectRes);
289 }
290
291 /*
292 * Feature: UriPermissionManagerClient
293 * Function: CheckUriAuthorization
294 * SubFunction: CheckUriAuthorization
295 * FunctionPoints: Size of uris is more than 500
296 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
297 */
298 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_003, TestSize.Level1)
299 {
300 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
301 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
302 std::vector<std::string> uriVec(501, uriStr);
303 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
304 uint32_t tokenId = 1001;
305 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
306 std::vector<bool> expectRes(501, false);
307 EXPECT_EQ(res, expectRes);
308 }
309
310 /*
311 * Feature: UriPermissionManagerClient
312 * Function: GrantUriPermissionPrivileged
313 * SubFunction: GrantUriPermissionPrivileged
314 * FunctionPoints: Size of uris is 0
315 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
316 */
317 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_001, TestSize.Level1)
318 {
319 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
320 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
321 std::vector<Uri> uriVec;
322 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
323 std::string bundleName = "com.example.test1001";
324 int32_t appIndex = 0;
325 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
326 EXPECT_EQ(res, ERR_URI_LIST_OUT_OF_RANGE);
327 }
328
329 /*
330 * Feature: UriPermissionManagerClient
331 * Function: GrantUriPermissionPrivileged
332 * SubFunction: GrantUriPermissionPrivileged
333 * FunctionPoints: Size of uris is more than 500
334 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
335 */
336 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_002, TestSize.Level1)
337 {
338 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
339 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
340 std::vector<Uri> uriVec(501, Uri(uriStr));
341 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
342 std::string bundleName = "com.example.test1001";
343 int32_t appIndex = 0;
344 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
345 EXPECT_EQ(res, ERR_URI_LIST_OUT_OF_RANGE);
346 }
347
348 /*
349 * Feature: UriPermissionManagerClient
350 * Function: GrantUriPermissionPrivileged
351 * SubFunction: GrantUriPermissionPrivileged
352 * FunctionPoints: size of uri is between 1 and 500
353 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
354 */
355 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_003, TestSize.Level1)
356 {
357 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
358 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
359 std::vector<Uri> uriVec(1, Uri(uriStr));
360 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
361 std::string bundleName = "com.example.test1001";
362 int32_t appIndex = 0;
363 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
364 EXPECT_EQ(res, CHECK_PERMISSION_FAILED);
365 }
366 } // namespace AAFwk
367 } // namespace OHOS