1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd. All rights reserved.
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 <gtest/gtest.h>
18 #include <sys/stat.h>
19 #include <memory>
20
21 #include "assistant.h"
22 #include "dfs_error.h"
23 #include "fuse_manager/fuse_manager.h"
24 #include "fuse_manager.cpp"
25 #include "utils_log.h"
26
27 namespace OHOS::FileManagement::CloudFile::Test {
28 using namespace CloudDisk;
29 using namespace testing;
30 using namespace testing::ext;
31 constexpr int32_t USER_ID = 100;
32 class FuseManagerStaticTest : 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<AssistantMock> insMock = nullptr;
40 };
41
SetUpTestCase(void)42 void FuseManagerStaticTest::SetUpTestCase(void)
43 {
44 GTEST_LOG_(INFO) << "SetUpTestCase";
45 insMock = make_shared<AssistantMock>();
46 Assistant::ins = insMock;
47 }
48
TearDownTestCase(void)49 void FuseManagerStaticTest::TearDownTestCase(void)
50 {
51 GTEST_LOG_(INFO) << "TearDownTestCase";
52 Assistant::ins = nullptr;
53 insMock = nullptr;
54 }
55
SetUp(void)56 void FuseManagerStaticTest::SetUp(void)
57 {
58 GTEST_LOG_(INFO) << "SetUp";
59 fuseManager_ = std::make_shared<FuseManager>();
60 }
61
TearDown(void)62 void FuseManagerStaticTest::TearDown(void)
63 {
64 GTEST_LOG_(INFO) << "TearDown";
65 }
66
67 /**
68 * @tc.name: IsValidCachePathTest001
69 * @tc.desc: Verify the IsValidCachePath function
70 * @tc.type: FUNC
71 * @tc.require: I6H5MH
72 */
73 HWTEST_F(FuseManagerStaticTest, IsValidCachePathTest001, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "IsValidCachePathTest001 Begin";
76 try {
77 string path = "/./";
78 auto ret = IsValidCachePath(path);
79
80 EXPECT_EQ(ret, false);
81 } catch (...) {
82 EXPECT_TRUE(false);
83 GTEST_LOG_(INFO) << "IsValidCachePathTest001 Error";
84 }
85 GTEST_LOG_(INFO) << "IsValidCachePathTest001 End";
86 }
87
88 /**
89 * @tc.name: IsValidCachePathTest002
90 * @tc.desc: Verify the IsValidCachePath function
91 * @tc.type: FUNC
92 * @tc.require: I6H5MH
93 */
94 HWTEST_F(FuseManagerStaticTest, IsValidCachePathTest002, TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "IsValidCachePathTest002 Begin";
97 try {
98 string path = "/mnt/data/100/cloud_fuse/../";
99 auto ret = IsValidCachePath(path);
100
101 EXPECT_EQ(ret, false);
102 } catch (...) {
103 EXPECT_TRUE(false);
104 GTEST_LOG_(INFO) << "IsValidCachePathTest002 Error";
105 }
106 GTEST_LOG_(INFO) << "IsValidCachePathTest002 End";
107 }
108
109 /**
110 * @tc.name: IsValidCachePathTest003
111 * @tc.desc: Verify the IsValidCachePath function
112 * @tc.type: FUNC
113 * @tc.require: I6H5MH
114 */
115 HWTEST_F(FuseManagerStaticTest, IsValidCachePathTest003, TestSize.Level1)
116 {
117 GTEST_LOG_(INFO) << "IsValidCachePathTest003 Begin";
118 try {
119 string path = "/mnt/data/100/cloud_fuse/..";
120 auto ret = IsValidCachePath(path);
121
122 EXPECT_EQ(ret, false);
123 } catch (...) {
124 EXPECT_TRUE(false);
125 GTEST_LOG_(INFO) << "IsValidCachePathTest003 Error";
126 }
127 GTEST_LOG_(INFO) << "IsValidCachePathTest003 End";
128 }
129
130 /**
131 * @tc.name: IsValidCachePathTest004
132 * @tc.desc: Verify the IsValidCachePath function
133 * @tc.type: FUNC
134 * @tc.require: I6H5MH
135 */
136 HWTEST_F(FuseManagerStaticTest, IsValidCachePathTest004, TestSize.Level1)
137 {
138 GTEST_LOG_(INFO) << "IsValidCachePathTest004 Begin";
139 try {
140 string path = "/mnt/data/100/cloud_fuse/";
141 auto ret = IsValidCachePath(path);
142
143 EXPECT_EQ(ret, true);
144 } catch (...) {
145 EXPECT_TRUE(false);
146 GTEST_LOG_(INFO) << "IsValidCachePathTest004 Error";
147 }
148 GTEST_LOG_(INFO) << "IsValidCachePathTest004 End";
149 }
150
151 /**
152 * @tc.name: DoSessionInitTest001
153 * @tc.desc: Verify the DoSessionInit function
154 * @tc.type: FUNC
155 * @tc.require: I6H5MH
156 */
157 HWTEST_F(FuseManagerStaticTest, DoSessionInitTest001, TestSize.Level1)
158 {
159 GTEST_LOG_(INFO) << "DoSessionInitTest001 start";
160 try {
161 auto cInode = make_shared<CloudInode>();
162 auto err = make_shared<CloudError>();
163 auto openFinish = make_shared<bool>();
164 auto cond = make_shared<ffrt::condition_variable>();
165 cInode->readSession = make_shared<CloudFile::CloudAssetReadSession>(0, "", "", "", "");
166 cInode->mBase = make_shared<MetaBase>("test");
167 cInode->mBase->fileType = FILE_TYPE_THUMBNAIL;
168
169 DoSessionInit(cInode, err, openFinish, cond);
170 EXPECT_TRUE(err);
171 } catch (...) {
172 EXPECT_TRUE(false);
173 GTEST_LOG_(INFO) << "DoSessionInitTest failed";
174 }
175 GTEST_LOG_(INFO) << "DoSessionInitTest end";
176 }
177
178 /**
179 * @tc.name: FindKeyInCloudFdCacheTest001
180 * @tc.desc: Verify the FindKeyInCloudFdCache function
181 * @tc.type: FUNC
182 * @tc.require: I6H5MH
183 */
184 HWTEST_F(FuseManagerStaticTest, FindKeyInCloudFdCacheTest001, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "FindKeyInCloudFdCacheTest001 start";
187 try {
188 auto cInode = make_shared<FuseData>();
189 uint64_t key = 100;
190 auto newCloudFdInfo = std::make_shared<struct CloudFdInfo>();
191 cInode->cloudFdCache[key] = newCloudFdInfo;
192 auto ret = FindKeyInCloudFdCache(cInode.get(), key);
193 EXPECT_NE(ret, nullptr);
194 } catch (...) {
195 EXPECT_TRUE(false);
196 GTEST_LOG_(INFO) << "FindKeyInCloudFdCacheTest failed";
197 }
198 GTEST_LOG_(INFO) << "FindKeyInCloudFdCacheTest end";
199 }
200
201 /**
202 * @tc.name: FindKeyInCloudFdCacheTest002
203 * @tc.desc: Verify the FindKeyInCloudFdCache function
204 * @tc.type: FUNC
205 * @tc.require: I6H5MH
206 */
207 HWTEST_F(FuseManagerStaticTest, FindKeyInCloudFdCacheTest002, TestSize.Level1)
208 {
209 GTEST_LOG_(INFO) << "FindKeyInCloudFdCacheTest002 start";
210 try {
211 auto cInode = make_shared<FuseData>();
212 uint64_t key = 1;
213 auto ret = FindKeyInCloudFdCache(cInode.get(), key);
214 EXPECT_EQ(ret, nullptr);
215 } catch (...) {
216 EXPECT_TRUE(false);
217 GTEST_LOG_(INFO) << "FindKeyInCloudFdCacheTest failed";
218 }
219 GTEST_LOG_(INFO) << "FindKeyInCloudFdCacheTest end";
220 }
221
222 /**
223 * @tc.name: SaveAppIdTest001
224 * @tc.desc: Verify the CloudRead function
225 * @tc.type: FUNC
226 * @tc.require: I6H5MH
227 */
228 HWTEST_F(FuseManagerStaticTest, SaveAppIdTest001, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "SaveAppIdTest001 start";
231 try {
232 fuse_req_t req = nullptr;
233 fuse_ino_t ino = 0;
234 struct fuse_file_info* fi = nullptr;
235 const void* inBuf = nullptr;
236 FuseData data;
237 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
238 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
239
240 SaveAppId(req, ino, fi, inBuf);
241 } catch (...) {
242 EXPECT_TRUE(false);
243 GTEST_LOG_(INFO) << "SaveAppIdTest001 failed";
244 }
245 GTEST_LOG_(INFO) << "SaveAppIdTest001 end";
246 }
247
248 /**
249 * @tc.name: SaveAppIdTest002
250 * @tc.desc: Verify the CloudRead function
251 * @tc.type: FUNC
252 * @tc.require: I6H5MH
253 */
254 HWTEST_F(FuseManagerStaticTest, SaveAppIdTest002, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "SaveAppIdTest002 start";
257 try {
258 fuse_req_t req = nullptr;
259 fuse_ino_t ino = 100;
260 struct fuse_file_info* fi = nullptr;
261 const void* inBuf = nullptr;
262 FuseData data;
263 shared_ptr<CloudInode> cloudInode = make_shared<CloudInode>();
264 cloudInode->readSession = make_shared<CloudFile::CloudAssetReadSession>(100, "", "", "", "");
265 data.inodeCache.insert({100, cloudInode});
266 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
267 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
268
269 SaveAppId(req, ino, fi, inBuf);
270 } catch (...) {
271 EXPECT_TRUE(false);
272 GTEST_LOG_(INFO) << "SaveAppIdTest002 failed";
273 }
274 GTEST_LOG_(INFO) << "SaveAppIdTest002 end";
275 }
276
277 /**
278 * @tc.name: SaveAppIdTest003
279 * @tc.desc: Verify the CloudRead function
280 * @tc.type: FUNC
281 * @tc.require: I6H5MH
282 */
283 HWTEST_F(FuseManagerStaticTest, SaveAppIdTest003, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "SaveAppIdTest003 start";
286 try {
287 fuse_req_t req = nullptr;
288 fuse_ino_t ino = 100;
289 struct fuse_file_info fi;
290 HmdfsSaveAppId hsaId;
291 const void* inBuf = &hsaId;
292 FuseData data;
293 fi.fh = 100;
294 shared_ptr<CloudInode> cloudInode = make_shared<CloudInode>();
295 shared_ptr<CloudFdInfo> cloudFdInfo = make_shared<CloudFdInfo>();
296 cloudInode->readSession = make_shared<CloudFile::CloudAssetReadSession>(100, "", "", "", "");
297 data.inodeCache.insert({100, cloudInode});
298 data.cloudFdCache.insert({100, cloudFdInfo});
299 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
300 EXPECT_CALL(*insMock, fuse_reply_ioctl(_, _, _, _)).WillOnce(Return(E_OK));
301
302 SaveAppId(req, ino, &fi, inBuf);
303 } catch (...) {
304 EXPECT_TRUE(false);
305 GTEST_LOG_(INFO) << "SaveAppIdTest003 failed";
306 }
307 GTEST_LOG_(INFO) << "SaveAppIdTest003 end";
308 }
309
310 /**
311 * @tc.name: DeleteFdsanTest001
312 * @tc.desc: Verify the DeleteFdsan function
313 * @tc.type: FUNC
314 * @tc.require: I6H5MH
315 */
316 HWTEST_F(FuseManagerStaticTest, DeleteFdsanTest001, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO) << "DeleteFdsanTest001 start";
319 try {
320 auto cloudFdInfo = make_shared<struct CloudFdInfo>();
321 cloudFdInfo->fdsan = UINT64_MAX;
322
323 DeleteFdsan(nullptr);
324 EXPECT_EQ(cloudFdInfo->fdsan, UINT64_MAX);
325 } catch (...) {
326 EXPECT_TRUE(false);
327 GTEST_LOG_(INFO) << "DeleteFdsanTest001 failed";
328 }
329 GTEST_LOG_(INFO) << "DeleteFdsanTest001 end";
330 }
331
332 /**
333 * @tc.name: DeleteFdsanTest002
334 * @tc.desc: Verify the DeleteFdsan function
335 * @tc.type: FUNC
336 * @tc.require: I6H5MH
337 */
338 HWTEST_F(FuseManagerStaticTest, DeleteFdsanTest002, TestSize.Level1)
339 {
340 GTEST_LOG_(INFO) << "DeleteFdsanTest002 start";
341 try {
342 auto cloudFdInfo = make_shared<struct CloudFdInfo>();
343 cloudFdInfo->fdsan = UINT64_MAX;
344
345 DeleteFdsan(cloudFdInfo);
346 EXPECT_EQ(cloudFdInfo->fdsan, UINT64_MAX);
347 } catch (...) {
348 EXPECT_TRUE(false);
349 GTEST_LOG_(INFO) << "DeleteFdsanTest002 failed";
350 }
351 GTEST_LOG_(INFO) << "DeleteFdsanTest002 end";
352 }
353
354 /**
355 * @tc.name: DeleteFdsanTest003
356 * @tc.desc: Verify the DeleteFdsan function
357 * @tc.type: FUNC
358 * @tc.require: I6H5MH
359 */
360 HWTEST_F(FuseManagerStaticTest, DeleteFdsanTest003, TestSize.Level1)
361 {
362 GTEST_LOG_(INFO) << "DeleteFdsanTest003 start";
363 try {
364 auto cloudFdInfo = make_shared<struct CloudFdInfo>();
365 cloudFdInfo->fdsan = reinterpret_cast<uint64_t>(new fdsan_fd());
366
367 DeleteFdsan(cloudFdInfo);
368 EXPECT_EQ(cloudFdInfo->fdsan, UINT64_MAX);
369 } catch (...) {
370 EXPECT_TRUE(false);
371 GTEST_LOG_(INFO) << "DeleteFdsanTest003 failed";
372 }
373 GTEST_LOG_(INFO) << "DeleteFdsanTest003 end";
374 }
375
376 /**
377 * @tc.name: IsHdc001
378 * @tc.desc: Verify the IsHdc function
379 * @tc.type: FUNC
380 */
381 HWTEST_F(FuseManagerStaticTest, IsHdc001, TestSize.Level1)
382 {
383 GTEST_LOG_(INFO) << "IsHdc001 Begin";
384 try {
385 struct FuseData data;
386 data.activeBundle = CloudSync::GALLERY_BUNDLE_NAME;
387 bool ret = IsHdc(&data);
388
389 EXPECT_EQ(ret, false);
390 } catch (...) {
391 EXPECT_TRUE(false);
392 GTEST_LOG_(INFO) << "IsHdc001 Error";
393 }
394 GTEST_LOG_(INFO) << "IsHdc001 End";
395 }
396
397 /**
398 * @tc.name: IsHdc002
399 * @tc.desc: Verify the IsHdc function
400 * @tc.type: FUNC
401 */
402 HWTEST_F(FuseManagerStaticTest, IsHdc002, TestSize.Level1)
403 {
404 GTEST_LOG_(INFO) << "IsHdc002 Begin";
405 try {
406 struct FuseData data;
407 data.activeBundle = CloudSync::HDC_BUNDLE_NAME;
408 bool ret = IsHdc(&data);
409
410 EXPECT_EQ(ret, true);
411 } catch (...) {
412 EXPECT_TRUE(false);
413 GTEST_LOG_(INFO) << "IsHdc002 Error";
414 }
415 GTEST_LOG_(INFO) << "IsHdc002 End";
416 }
417
418 /**
419 * @tc.name: UpdateReadStatInfoTest001
420 * @tc.desc: Verify the UpdateReadStatInfo function
421 * @tc.type: FUNC
422 * @tc.require:ICTLI4
423 */
424 HWTEST_F(FuseManagerStaticTest, UpdateReadStatInfoTest001, TestSize.Level1)
425 {
426 GTEST_LOG_(INFO) << "UpdateReadStatInfoTest001 Begin";
427 try {
428 CloudDaemonStatistic &readStat = CloudDaemonStatistic::GetInstance();
429 readStat.bundleName_ = "";
430 size_t size = 1;
431 string name = "name";
432 uint64_t readTime = 1;
433 string bundleName = "test.bundle.name";
434 UpdateReadStatInfo(size, name, 1, bundleName);
435 EXPECT_EQ(readStat.bundleName_, "test.bundle.name");
436 } catch (...) {
437 EXPECT_TRUE(false);
438 GTEST_LOG_(INFO) << "UpdateReadStatInfoTest001 Error";
439 }
440 GTEST_LOG_(INFO) << "UpdateReadStatInfoTest001 End";
441 }
442
443 /**
444 * @tc.name: UpdateReadStatInfoTest002
445 * @tc.desc: Verify the UpdateReadStatInfo function
446 * @tc.type: FUNC
447 * @tc.require:ICTLI4
448 */
449 HWTEST_F(FuseManagerStaticTest, UpdateReadStatInfoTest002, TestSize.Level1)
450 {
451 GTEST_LOG_(INFO) << "UpdateReadStatInfoTest002 Begin";
452 try {
453 CloudDaemonStatistic &readStat = CloudDaemonStatistic::GetInstance();
454 readStat.bundleName_ = "test.bundle.name";
455 size_t size = 1;
456 string name = "name";
457 uint64_t readTime = 1;
458 string bundleName = "new.bundle.name";
459 UpdateReadStatInfo(size, name, 1, bundleName);
460 EXPECT_EQ(readStat.bundleName_, "new.bundle.name");
461 } catch (...) {
462 EXPECT_TRUE(false);
463 GTEST_LOG_(INFO) << "UpdateReadStatInfoTest002 Error";
464 }
465 GTEST_LOG_(INFO) << "UpdateReadStatInfoTest002 End";
466 }
467
468 /**
469 * @tc.name: UpdateReadStatTest001
470 * @tc.desc: Verify the UpdateReadStat function
471 * @tc.type: FUNC
472 * @tc.require:ICTLI4
473 */
474 HWTEST_F(FuseManagerStaticTest, UpdateReadStatTest001, TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "UpdateReadStatTest001 Begin";
477 try {
478 CloudDaemonStatistic &readStat = CloudDaemonStatistic::GetInstance();
479 readStat.bundleName_ = "";
480 auto cInode = make_shared<CloudInode>();
481 cInode->mBase = make_shared<MetaBase>("test");
482 cInode->mBase->fileType = FILE_TYPE_THUMBNAIL;
483 uint64_t startTime = 1;
484 string bundleName = "test.bundle.name";
485 UpdateReadStat(cInode, startTime, bundleName);
486 EXPECT_EQ(readStat.bundleName_, "test.bundle.name");
487 } catch (...) {
488 EXPECT_TRUE(false);
489 GTEST_LOG_(INFO) << "UpdateReadStatTest001 Error";
490 }
491 GTEST_LOG_(INFO) << "UpdateReadStatTest001 End";
492 }
493
494 /**
495 * @tc.name: UpdateReadStatTest002
496 * @tc.desc: Verify the UpdateReadStat function
497 * @tc.type: FUNC
498 * @tc.require:ICTLI4
499 */
500 HWTEST_F(FuseManagerStaticTest, UpdateReadStatTest002, TestSize.Level1)
501 {
502 GTEST_LOG_(INFO) << "UpdateReadStatTest002 Begin";
503 try {
504 CloudDaemonStatistic &readStat = CloudDaemonStatistic::GetInstance();
505 readStat.bundleName_ = "test.bundle.name";
506 auto cInode = make_shared<CloudInode>();
507 cInode->mBase = make_shared<MetaBase>("test");
508 cInode->mBase->fileType = FILE_TYPE_THUMBNAIL;
509 uint64_t startTime = 1;
510 string bundleName = "new.bundle.name";
511 UpdateReadStat(cInode, startTime, bundleName);
512 EXPECT_EQ(readStat.bundleName_, "new.bundle.name");
513 } catch (...) {
514 EXPECT_TRUE(false);
515 GTEST_LOG_(INFO) << "UpdateReadStatTest002 Error";
516 }
517 GTEST_LOG_(INFO) << "UpdateReadStatTest002 End";
518 }
519 } // namespace OHOS::FileManagement::CloudSync::Test