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 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
243 int32_t devFd = open("/dev/fuse", O_RDWR);
244 string path = "/invalid/data/100/cloud_fuse";
245 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
246 close(devFd);
247 EXPECT_EQ(ret, -EINVAL);
248 } catch (...) {
249 EXPECT_TRUE(false);
250 GTEST_LOG_(INFO) << "StartFuseTest007 failed";
251 }
252 GTEST_LOG_(INFO) << "StartFuseTest007 end";
253 }
254
255 /**
256 * @tc.name: StartFuseTest008
257 * @tc.desc: Verify the StartFuse function
258 * @tc.type: FUNC
259 * @tc.require: issuesIB538J
260 */
261 HWTEST_F(FuseManagerTest, StartFuseTest008, TestSize.Level1)
262 {
263 GTEST_LOG_(INFO) << "StartFuseTest008 start";
264 try {
265 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
266 int32_t devFd = open("/dev/fuse", O_RDWR);
267 string path = "/mnt/other/100/cloud_fuse";
268 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
269 close(devFd);
270 EXPECT_EQ(ret, -EINVAL);
271 } catch (...) {
272 EXPECT_TRUE(false);
273 GTEST_LOG_(INFO) << "StartFuseTest008 failed";
274 }
275 GTEST_LOG_(INFO) << "StartFuseTest008 end";
276 }
277
278 /**
279 * @tc.name: StartFuseTest009
280 * @tc.desc: Verify the StartFuse function
281 * @tc.type: FUNC
282 * @tc.require: issuesIB538J
283 */
284 HWTEST_F(FuseManagerTest, StartFuseTest009, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "StartFuseTest009 start";
287 try {
288 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
289 int32_t devFd = open("/dev/fuse", O_RDWR);
290 string path = "/mnt/data/abcd/cloud_fuse";
291 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
292 close(devFd);
293 EXPECT_EQ(ret, -EINVAL);
294 } catch (...) {
295 EXPECT_TRUE(false);
296 GTEST_LOG_(INFO) << "StartFuseTest009 failed";
297 }
298 GTEST_LOG_(INFO) << "StartFuseTest009 end";
299 }
300
301 /**
302 * @tc.name: StartFuseTest010
303 * @tc.desc: Verify the StartFuse function
304 * @tc.type: FUNC
305 * @tc.require: issuesIB538J
306 */
307 HWTEST_F(FuseManagerTest, StartFuseTest010, TestSize.Level1)
308 {
309 GTEST_LOG_(INFO) << "StartFuseTest010 start";
310 try {
311 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
312 int32_t devFd = open("/dev/fuse", O_RDWR);
313 string path = "/mnt/data/100/invalid_suffix";
314 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
315 close(devFd);
316 EXPECT_EQ(ret, -EINVAL);
317 } catch (...) {
318 EXPECT_TRUE(false);
319 GTEST_LOG_(INFO) << "StartFuseTest010 failed";
320 }
321 GTEST_LOG_(INFO) << "StartFuseTest010 end";
322 }
323
324 /**
325 * @tc.name: StartFuseTest011
326 * @tc.desc: Verify the StartFuse function
327 * @tc.type: FUNC
328 * @tc.require: issuesIB538J
329 */
330 HWTEST_F(FuseManagerTest, StartFuseTest011, TestSize.Level1)
331 {
332 GTEST_LOG_(INFO) << "StartFuseTest011 start";
333 try {
334 EXPECT_CALL(*insMock_, fuse_opt_add_arg(_, _)).WillOnce(Return(0));
335 int32_t devFd = open("/dev/fuse", O_RDWR);
336 string path = "\0";
337 int ret = fuseManager_->StartFuse(USER_ID, devFd, path);
338 close(devFd);
339 EXPECT_EQ(ret, -EINVAL);
340 } catch (...) {
341 EXPECT_TRUE(false);
342 GTEST_LOG_(INFO) << "StartFuseTest011 failed";
343 }
344 GTEST_LOG_(INFO) << "StartFuseTest011 end";
345 }
346 } // namespace OHOS::FileManagement::CloudSync::Test