1 /*
2  * Copyright (c) 2023 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 
16 #include <cassert>
17 #include <fcntl.h>
18 #include <gtest/gtest.h>
19 
20 #include <singleton.h>
21 #include <string>
22 #include <sys/mount.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 
26 #include "access_token_error.h"
27 #include "accesstoken_kit.h"
28 #include "file_share.h"
29 #include "ipc_skeleton.h"
30 #include "log.h"
31 #include "sandbox_helper.h"
32 #include "uri.h"
33 
34 namespace {
35 using namespace std;
36 using namespace OHOS::AppFileService;
37 using namespace OHOS::Security::AccessToken;
38 
39 const int E_OK = 0;
40 const string BUNDLE_A = "com.example.filesharea";
41 
42 class FileShareTest : public testing::Test {
43 public:
SetUpTestCase(void)44     static void SetUpTestCase(void) {};
TearDownTestCase()45     static void TearDownTestCase() {};
SetUp()46     void SetUp() {};
TearDown()47     void TearDown() {};
48 };
49 
50 /**
51  * @tc.name: file_share_test_0000
52  * @tc.desc: Test function of CreateShareFile() interface for SUCCESS.
53  * @tc.size: MEDIUM
54  * @tc.type: FUNC
55  * @tc.level Level 1
56  * @tc.require: SR000H63TL
57  */
58 HWTEST_F(FileShareTest, File_share_CreateShareFile_0000, testing::ext::TestSize.Level1)
59 {
60     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0000";
61 
62     int32_t uid = 100;
63 
64     string bundleNameA = "com.example.filesharea";
65     string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt";
66     int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
67     ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!";
68     close(fd);
69     string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt";
70 
71     string bundleNameB = "com.example.fileshareb";
72     uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0);
73 
74     int32_t flag = 3;
75     vector<string> uriList(1, uri);
76     vector<int32_t> retList;
77     int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList);
78     EXPECT_EQ(ret, E_OK);
79 
80     uriList.clear();
81     retList.clear();
82     uri.clear();
83     uri = "file://" + bundleNameA + "/data/storage/el2/base/files/../files/test.txt";
84     uriList.push_back(uri);
85     ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList);
86     EXPECT_EQ(ret, -EINVAL);
87     GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0000";
88 }
89 
90 /**
91  * @tc.name: file_share_test_0001
92  * @tc.desc: Test function of CreateShareFile() interface for SUCCESS.
93  * @tc.size: MEDIUM
94  * @tc.type: FUNC
95  * @tc.level Level 1
96  * @tc.require: SR000H63TL
97  */
98 HWTEST_F(FileShareTest, File_share_CreateShareFile_0001, testing::ext::TestSize.Level1)
99 {
100     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0001";
101 
102     int32_t uid = 100;
103 
104     string bundleNameA = "com.example.filesharea";
105     string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt";
106     int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
107     ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!";
108     close(fd);
109     string uri = "file://" + bundleNameA + "/data/test/el2/base/files/test.txt";
110 
111     string bundleNameB = "com.example.fileshareb";
112     uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0);
113 
114     int32_t flag = 3;
115     vector<string> uriList(1, uri);
116     vector<int32_t> retList;
117     int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList);
118     EXPECT_EQ(ret, -EINVAL);
119     GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0001";
120 }
121 
122 /**
123  * @tc.name: file_share_test_0002
124  * @tc.desc: Test function of CreateShareFile() interface for SUCCESS.
125  * @tc.size: MEDIUM
126  * @tc.type: FUNC
127  * @tc.level Level 1
128  * @tc.require: SR000H63TL
129  */
130 HWTEST_F(FileShareTest, File_share_CreateShareFile_0002, testing::ext::TestSize.Level1)
131 {
132     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0002";
133     int32_t uid = 100;
134 
135     string bundleNameA = "com.example.filesharea";
136     string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt";
137     int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
138     ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!";
139     close(fd);
140     string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt";
141     uint32_t tokenId = 100;
142 
143     int32_t flag = 3;
144     vector<string> uriList(1, uri);
145     vector<int32_t> retList;
146     int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList);
147     EXPECT_EQ(ret, static_cast<int32_t>(AccessTokenError::ERR_TOKENID_NOT_EXIST));
148     GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0002";
149 }
150 
151 /**
152  * @tc.name: file_share_test_0003
153  * @tc.desc: Test function of CreateShareFile() interface for SUCCESS.
154  * @tc.size: MEDIUM
155  * @tc.type: FUNC
156  * @tc.level Level 1
157  * @tc.require: SR000H63TL
158  */
159 HWTEST_F(FileShareTest, File_share_CreateShareFile_0003, testing::ext::TestSize.Level1)
160 {
161     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0003";
162     int32_t uid = 100;
163 
164     string bundleNameA = "com.example.filesharea";
165     string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt";
166     int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
167     ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!";
168     close(fd);
169     string uri = "";
170 
171     string bundleNameB = "com.example.fileshareb";
172     uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0);
173 
174     int32_t flag = 3;
175     vector<string> uriList(1, uri);
176     vector<int32_t> retList;
177     int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList);
178     EXPECT_EQ(ret, -EINVAL);
179     GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0003";
180 }
181 
182 /**
183  * @tc.name: file_share_test_0004
184  * @tc.desc: Test function of CreateShareFile() interface for SUCCESS.
185  * @tc.size: MEDIUM
186  * @tc.type: FUNC
187  * @tc.level Level 1
188  * @tc.require: SR000H63TL
189  */
190 HWTEST_F(FileShareTest, File_share_CreateShareFile_0004, testing::ext::TestSize.Level1)
191 {
192     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0004";
193     int32_t uid = 100;
194 
195     string bundleNameA = "com.example.filesharea";
196     string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt";
197     int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
198     ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!";
199     close(fd);
200     string uri = "";
201 
202     string bundleNameB = "com.example.fileshareb";
203     uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0);
204 
205     int32_t flag = 4;
206     vector<string> uriList(1, uri);
207     vector<int32_t> retList;
208     int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList);
209     EXPECT_EQ(ret, -EINVAL);
210     GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0004";
211 }
212 
213 /**
214  * @tc.name: file_share_test_0005
215  * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS.
216  * @tc.size: MEDIUM
217  * @tc.type: FUNC
218  * @tc.level Level 1
219  * @tc.require: SR000H63TL
220  */
221 HWTEST_F(FileShareTest, File_share_DeleteShareFile_0005, testing::ext::TestSize.Level1)
222 {
223     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0005";
224     int32_t uid = 100;
225 
226     string bundleNameB = "com.example.fileshareb";
227     uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0);
228     vector<string> sharePathList;
229     string bundleNameA = "com.example.filesharea";
230     string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt";
231     sharePathList.push_back(uri);
232     int32_t ret = FileShare::DeleteShareFile(tokenId, sharePathList);
233     EXPECT_EQ(ret, E_OK);
234     GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0005";
235 }
236 
237 /**
238  * @tc.name: file_share_test_0006
239  * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS.
240  * @tc.size: MEDIUM
241  * @tc.type: FUNC
242  * @tc.level Level 1
243  * @tc.require: SR000H63TL
244  */
245 HWTEST_F(FileShareTest, File_share_DeleteShareFile_0006, testing::ext::TestSize.Level1)
246 {
247     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0006";
248     uint32_t tokenId = 104;
249     vector<string> sharePathList;
250     string bundleNameA = "com.example.filesharea";
251     string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt";
252     sharePathList.push_back(uri);
253     int32_t ret = FileShare::DeleteShareFile(tokenId, sharePathList);
254     EXPECT_EQ(ret, -EINVAL);
255     GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0006";
256 }
257 
258 /**
259  * @tc.name: File_share_DeleteShareFile_0007
260  * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS.
261  * @tc.size: MEDIUM
262  * @tc.type: FUNC
263  * @tc.level Level 1
264  * @tc.require: SR000H63TL
265  */
266 HWTEST_F(FileShareTest, File_share_DeleteShareFile_0007, testing::ext::TestSize.Level1)
267 {
268     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0007";
269     int32_t uid = 100;
270 
271     string bundleNameA = "com.example.filesharea";
272     string file = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt";
273     int32_t fd = open(file.c_str(), O_RDWR | O_CREAT);
274     ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!";
275     close(fd);
276     string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt";
277 
278     string bundleNameB = "com.example.fileshareb";
279     uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0);
280 
281     int32_t flag = 3;
282     vector<string> uriList(1, uri);
283     vector<int32_t> retLists;
284     int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retLists);
285     EXPECT_EQ(ret, E_OK);
286 
287     vector<string> sharePathLists;
288     string uriErr = "file://" + bundleNameA + "/data/storage/el2/base/files/abc/../test.txt";
289     sharePathLists.push_back(uriErr);
290     ret = FileShare::DeleteShareFile(tokenId, sharePathLists);
291     EXPECT_EQ(ret, E_OK);
292 
293     string sharePath = "/data/service/el2/" + to_string(uid) + "/share/" + bundleNameB + "/rw/" + bundleNameA +
294                        "/data/storage/el2/base/files/test.txt";
295     ret = access(sharePath.c_str(), F_OK);
296     EXPECT_EQ(ret, E_OK);
297 
298     sharePathLists.push_back(uri);
299     ret = FileShare::DeleteShareFile(tokenId, sharePathLists);
300     EXPECT_EQ(ret, E_OK);
301 
302     ret = access(sharePath.c_str(), F_OK);
303     EXPECT_EQ(ret, -1);
304     GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0007";
305 }
306 
307 /**
308  * @tc.name: File_share_GetPhysicalPath_0001
309  * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS.
310  * @tc.size: MEDIUM
311  * @tc.type: FUNC
312  * @tc.level Level 1
313  * @tc.require: I7PDZL
314  */
315 HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0001, testing::ext::TestSize.Level1)
316 {
317     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0001";
318     std::string fileUri = "file://media/Photo/12/IMG_12345_0011/test.jpg";
319     std::string physicalPath;
320     int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath);
321     EXPECT_EQ(ret, E_OK);
322     EXPECT_EQ(physicalPath, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/11/IMG_12345_0011.jpg");
323     GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0001";
324 }
325 
326 /**
327  * @tc.name: File_share_GetPhysicalPath_0002
328  * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS.
329  * @tc.size: MEDIUM
330  * @tc.type: FUNC
331  * @tc.level Level 1
332  * @tc.require: I7PDZL
333  */
334 HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0002, testing::ext::TestSize.Level1)
335 {
336     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0002";
337     std::string fileUri = "file://media/Photo/12/IMG_12345_/test.jpg";
338     std::string physicalPath;
339     int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath);
340     EXPECT_EQ(ret, -EINVAL);
341     GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0002";
342 }
343 
344 /**
345  * @tc.name: File_share_GetPhysicalPath_0003
346  * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS.
347  * @tc.size: MEDIUM
348  * @tc.type: FUNC
349  * @tc.level Level 1
350  * @tc.require: I7PDZL
351  */
352 HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0003, testing::ext::TestSize.Level1)
353 {
354     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0003";
355     std::string fileUri = "file://media/Photo/12/IMG_12345_a0011/test.jpg";
356     std::string physicalPath;
357     int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath);
358     EXPECT_EQ(ret, -EINVAL);
359     GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0003";
360 }
361 
362 /**
363  * @tc.name: File_share_GetPhysicalPath_0004
364  * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS.
365  * @tc.size: MEDIUM
366  * @tc.type: FUNC
367  * @tc.level Level 1
368  * @tc.require: I7PDZL
369  */
370 HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0004, testing::ext::TestSize.Level1)
371 {
372     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0004";
373     std::string fileUri = "file://media/Photo/IMG_12345_999999/test.jpg";
374     std::string physicalPath;
375     int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath);
376     EXPECT_EQ(ret, -EINVAL);
377     GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0004";
378 }
379 
380 /**
381  * @tc.name: File_share_GetPhysicalPath_0005
382  * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS.
383  * @tc.size: MEDIUM
384  * @tc.type: FUNC
385  * @tc.level Level 1
386  * @tc.require: I7PDZL
387  */
388 HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0005, testing::ext::TestSize.Level1)
389 {
390     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0005";
391     std::string strPrefix = "file://media/";
392     std::string fileUri = "Photo/12/IMG_12345_999999/test.jpg";
393     std::string physicalPath;
394     int32_t ret = SandboxHelper::GetPhysicalPath(strPrefix + SandboxHelper::Encode(fileUri), "100", physicalPath);
395     EXPECT_EQ(ret, E_OK);
396     EXPECT_EQ(physicalPath, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/575/IMG_12345_999999.jpg");
397 
398     std::string fileUri2 = "Photo/12/IMG_12345_999999/test .jpg";
399     std::string physicalPath2;
400     ret = SandboxHelper::GetPhysicalPath(strPrefix + SandboxHelper::Encode(fileUri2), "100", physicalPath2);
401     EXPECT_EQ(ret, E_OK);
402     EXPECT_EQ(physicalPath2, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/575/IMG_12345_999999.jpg");
403     GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0005";
404 }
405 
406 /**
407  * @tc.name: File_share_GetPhysicalPath_0006
408  * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS.
409  * @tc.size: MEDIUM
410  * @tc.type: FUNC
411  * @tc.level Level 1
412  * @tc.require: I7PDZL
413  */
414 HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0006, testing::ext::TestSize.Level1)
415 {
416     GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0006";
417     std::string fileUri = "file://media/Photo/12/IMG_12345_999999/test.jpg/other";
418     std::string physicalPath;
419     int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath);
420     EXPECT_EQ(ret, -EINVAL);
421     GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0006";
422 }
423 } // namespace