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
16 #include <fcntl.h>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <sys/stat.h>
20 #include <memory>
21
22 #include "dfs_error.h"
23 #include "fuse_assistant.h"
24 #include "fuse_manager/fuse_manager.h"
25 #include "fuse_i.h"
26 #include "utils_log.h"
27
28 namespace OHOS::FileManagement::CloudFile::Test {
29 using namespace testing;
30 using namespace testing::ext;
31 constexpr int32_t USER_ID = 100;
32 class FuseManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 std::shared_ptr<FuseManager> fuseManager_;
39 static inline shared_ptr<FuseAssistantMock> insMock_ = nullptr;
40 };
41
SetUpTestCase(void)42 void FuseManagerTest::SetUpTestCase(void)
43 {
44 GTEST_LOG_(INFO) << "SetUpTestCase";
45 }
46
TearDownTestCase(void)47 void FuseManagerTest::TearDownTestCase(void)
48 {
49 GTEST_LOG_(INFO) << "TearDownTestCase";
50 }
51
SetUp(void)52 void FuseManagerTest::SetUp(void)
53 {
54 GTEST_LOG_(INFO) << "SetUp";
55 insMock_ = make_shared<FuseAssistantMock>();
56 FuseAssistantMock::ins = insMock_;
57 fuseManager_ = std::make_shared<FuseManager>();
58 }
59
TearDown(void)60 void FuseManagerTest::TearDown(void)
61 {
62 GTEST_LOG_(INFO) << "TearDown";
63 FuseAssistantMock::ins = nullptr;
64 insMock_ = nullptr;
65 }
66
67 /**
68 * @tc.name: GetInstanceTest
69 * @tc.desc: Verify the GetInstance function
70 * @tc.type: FUNC
71 * @tc.require: I6H5MH
72 */
73 HWTEST_F(FuseManagerTest, GetInstanceTest, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "GetInstanceTest start";
76 try {
77 FuseManager::GetInstance();
78 EXPECT_TRUE(true);
79 } catch (...) {
80 EXPECT_TRUE(false);
81 GTEST_LOG_(INFO) << "GetInstanceTest failed";
82 }
83 GTEST_LOG_(INFO) << "GetInstanceTest end";
84 }
85
86 /**
87 * @tc.name: StartFuseTest001
88 * @tc.desc: Verify the StartFuse function
89 * @tc.type: FUNC
90 * @tc.require: issuesIB538J
91 */
92 HWTEST_F(FuseManagerTest, StartFuseTest001, TestSize.Level1)
93 {
94 GTEST_LOG_(INFO) << "StartFuseTest001 start";
95 try {
96 std::unique_ptr<struct fuse_session> fs = std::make_unique<struct fuse_session>();
97 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
98 EXPECT_CALL(*insMock_, fuse_session_new(_, _, _, _)).WillOnce(Return(fs.get()));
99 EXPECT_CALL(*insMock_, fuse_session_destroy(fs.get())).WillOnce(Return());
100 int32_t devFd = open("/dev/fuse", O_RDWR);
101 string path = "/mnt/data/100/cloud_fuse";
102 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
103 close(devFd);
104 EXPECT_EQ(ret, -1);
105 } catch (...) {
106 EXPECT_TRUE(false);
107 GTEST_LOG_(INFO) << "StartFuseTest001 failed";
108 }
109 GTEST_LOG_(INFO) << "StartFuseTest001 end";
110 }
111
112 /**
113 * @tc.name: StartFuseTest002
114 * @tc.desc: Verify the StartFuse function
115 * @tc.type: FUNC
116 * @tc.require: issuesIB538J
117 */
118 HWTEST_F(FuseManagerTest, StartFuseTest002, TestSize.Level1)
119 {
120 GTEST_LOG_(INFO) << "StartFuseTest002 start";
121 try {
122 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(-1));
123 int32_t devFd = open("/dev/fuse", O_RDWR);
124 string path = "/mnt/data/100/cloud_fuse";
125 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
126 close(devFd);
127 EXPECT_EQ(ret, -EINVAL);
128 } catch (...) {
129 EXPECT_TRUE(false);
130 GTEST_LOG_(INFO) << "StartFuseTest002 failed";
131 }
132 GTEST_LOG_(INFO) << "StartFuseTest002 end";
133 }
134
135 /**
136 * @tc.name: StartFuseTest003
137 * @tc.desc: Verify the StartFuse function
138 * @tc.type: FUNC
139 * @tc.require: issuesIB538J
140 */
141 HWTEST_F(FuseManagerTest, StartFuseTest003, TestSize.Level1)
142 {
143 GTEST_LOG_(INFO) << "StartFuseTest003 start";
144 try {
145 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
146 EXPECT_CALL(*insMock_, fuse_session_new(_, _, _, _)).WillOnce(Return(nullptr));
147 int32_t devFd = open("/dev/fuse", O_RDWR);
148 string path = "/mnt/data/100/cloud_fuse";
149 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
150 close(devFd);
151 EXPECT_EQ(ret, -EINVAL);
152 } catch (...) {
153 EXPECT_TRUE(false);
154 GTEST_LOG_(INFO) << "StartFuseTest003 failed";
155 }
156 GTEST_LOG_(INFO) << "StartFuseTest003 end";
157 }
158
159 /**
160 * @tc.name: StartFuseTest004
161 * @tc.desc: Verify the StartFuse function
162 * @tc.type: FUNC
163 * @tc.require: issuesIB538J
164 */
165 HWTEST_F(FuseManagerTest, StartFuseTest004, TestSize.Level1)
166 {
167 GTEST_LOG_(INFO) << "StartFuseTest004 start";
168 try {
169 std::unique_ptr<struct fuse_session> fs = std::make_unique<struct fuse_session>();
170 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
171 EXPECT_CALL(*insMock_, fuse_session_new(_, _, _, _)).WillOnce(Return(fs.get()));
172 EXPECT_CALL(*insMock_, fuse_session_destroy(fs.get())).WillOnce(Return());
173 int32_t devFd = open("/dev/fuse", O_RDWR);
174 string path = "/mnt/data/100/cloud";
175 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
176 close(devFd);
177 EXPECT_EQ(ret, -1);
178 } catch (...) {
179 EXPECT_TRUE(false);
180 GTEST_LOG_(INFO) << "StartFuseTest004 failed";
181 }
182 GTEST_LOG_(INFO) << "StartFuseTest004 end";
183 }
184
185 /**
186 * @tc.name: StartFuseTest005
187 * @tc.desc: Verify the StartFuse function
188 * @tc.type: FUNC
189 * @tc.require: issuesIB538J
190 */
191 HWTEST_F(FuseManagerTest, StartFuseTest005, TestSize.Level1)
192 {
193 GTEST_LOG_(INFO) << "StartFuseTest005 start";
194 try {
195 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(-1));
196 int32_t devFd = open("/dev/fuse", O_RDWR);
197 string path = "/mnt/data/100/cloud";
198 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
199 close(devFd);
200 EXPECT_EQ(ret, -EINVAL);
201 } catch (...) {
202 EXPECT_TRUE(false);
203 GTEST_LOG_(INFO) << "StartFuseTest005 failed";
204 }
205 GTEST_LOG_(INFO) << "StartFuseTest005 end";
206 }
207
208 /**
209 * @tc.name: StartFuseTest006
210 * @tc.desc: Verify the StartFuse function
211 * @tc.type: FUNC
212 * @tc.require: issuesIB538J
213 */
214 HWTEST_F(FuseManagerTest, StartFuseTest006, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO) << "StartFuseTest006 start";
217 try {
218 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
219 EXPECT_CALL(*insMock_, fuse_session_new(_, _, _, _)).WillOnce(Return(nullptr));
220 int32_t devFd = open("/dev/fuse", O_RDWR);
221 string path = "/mnt/data/100/cloud";
222 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
223 close(devFd);
224 EXPECT_EQ(ret, -EINVAL);
225 } catch (...) {
226 EXPECT_TRUE(false);
227 GTEST_LOG_(INFO) << "StartFuseTest006 failed";
228 }
229 GTEST_LOG_(INFO) << "StartFuseTest006 end";
230 }
231
232 /**
233 * @tc.name: StartFuseTest007
234 * @tc.desc: Verify the StartFuse function
235 * @tc.type: FUNC
236 * @tc.require: issuesIB538J
237 */
238 HWTEST_F(FuseManagerTest, StartFuseTest007, TestSize.Level1)
239 {
240 GTEST_LOG_(INFO) << "StartFuseTest007 start";
241 try {
242 int32_t devFd = open("/dev/fuse", O_RDWR);
243 string path = "/invalid/data/100/cloud_fuse";
244 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
245 close(devFd);
246 EXPECT_EQ(ret, -EINVAL);
247 } catch (...) {
248 EXPECT_TRUE(false);
249 GTEST_LOG_(INFO) << "StartFuseTest007 failed";
250 }
251 GTEST_LOG_(INFO) << "StartFuseTest007 end";
252 }
253
254 /**
255 * @tc.name: StartFuseTest008
256 * @tc.desc: Verify the StartFuse function
257 * @tc.type: FUNC
258 * @tc.require: issuesIB538J
259 */
260 HWTEST_F(FuseManagerTest, StartFuseTest008, TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "StartFuseTest008 start";
263 try {
264 int32_t devFd = open("/dev/fuse", O_RDWR);
265 string path = "/mnt/other/100/cloud_fuse";
266 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
267 close(devFd);
268 EXPECT_EQ(ret, -EINVAL);
269 } catch (...) {
270 EXPECT_TRUE(false);
271 GTEST_LOG_(INFO) << "StartFuseTest008 failed";
272 }
273 GTEST_LOG_(INFO) << "StartFuseTest008 end";
274 }
275
276 /**
277 * @tc.name: StartFuseTest009
278 * @tc.desc: Verify the StartFuse function
279 * @tc.type: FUNC
280 * @tc.require: issuesIB538J
281 */
282 HWTEST_F(FuseManagerTest, StartFuseTest009, TestSize.Level1)
283 {
284 GTEST_LOG_(INFO) << "StartFuseTest009 start";
285 try {
286 int32_t devFd = open("/dev/fuse", O_RDWR);
287 string path = "/mnt/data/abcd/cloud_fuse";
288 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
289 close(devFd);
290 EXPECT_EQ(ret, -EINVAL);
291 } catch (...) {
292 EXPECT_TRUE(false);
293 GTEST_LOG_(INFO) << "StartFuseTest009 failed";
294 }
295 GTEST_LOG_(INFO) << "StartFuseTest009 end";
296 }
297
298 /**
299 * @tc.name: StartFuseTest010
300 * @tc.desc: Verify the StartFuse function
301 * @tc.type: FUNC
302 * @tc.require: issuesIB538J
303 */
304 HWTEST_F(FuseManagerTest, StartFuseTest010, TestSize.Level1)
305 {
306 GTEST_LOG_(INFO) << "StartFuseTest010 start";
307 try {
308 int32_t devFd = open("/dev/fuse", O_RDWR);
309 string path = "/mnt/data/100/invalid_suffix";
310 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
311 close(devFd);
312 EXPECT_EQ(ret, -EINVAL);
313 } catch (...) {
314 EXPECT_TRUE(false);
315 GTEST_LOG_(INFO) << "StartFuseTest010 failed";
316 }
317 GTEST_LOG_(INFO) << "StartFuseTest010 end";
318 }
319
320 /**
321 * @tc.name: StartFuseTest011
322 * @tc.desc: Verify the StartFuse function
323 * @tc.type: FUNC
324 * @tc.require: issuesIB538J
325 */
326 HWTEST_F(FuseManagerTest, StartFuseTest011, TestSize.Level1)
327 {
328 GTEST_LOG_(INFO) << "StartFuseTest011 start";
329 try {
330 int32_t devFd = open("/dev/fuse", O_RDWR);
331 string path = "\0";
332 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
333 close(devFd);
334 EXPECT_EQ(ret, -EINVAL);
335 } catch (...) {
336 EXPECT_TRUE(false);
337 GTEST_LOG_(INFO) << "StartFuseTest011 failed";
338 }
339 GTEST_LOG_(INFO) << "StartFuseTest011 end";
340 }
341 } // namespace OHOS::FileManagement::CloudSync::Test