1 /*
2 * Copyright (c) 2024-2025 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 "dfs_error.h"
17 #include <copy/file_copy_manager.h>
18 #include <copy/trans_listener.h>
19 #include <filesystem>
20 #include <fstream>
21 #include <gtest/gtest.h>
22 #include <memory>
23
24 namespace OHOS::Storage::DistributedFile::Test {
25 using namespace OHOS::FileManagement;
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace std;
29
30 class TransListenerTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36
37 // Variables to track file transfer progress
38 uint64_t process = 0; // Bytes processed so far
39 uint64_t fileSize = 0; // Total file size
40
41 // Callback definition for progress updates
42 using callBack = std::function<void(uint64_t processSize, uint64_t totalFileSize)>;
__anon7298b69d0102(uint64_t processSize, uint64_t totalFileSize) 43 callBack listener = [&](uint64_t processSize, uint64_t totalFileSize) {
44 process = processSize;
45 fileSize = totalFileSize;
46 };
47 callBack nullCallBack;
48 };
49
SetUpTestCase(void)50 void TransListenerTest::SetUpTestCase(void)
51 {
52 GTEST_LOG_(INFO) << "SetUpTestCase";
53 }
54
TearDownTestCase(void)55 void TransListenerTest::TearDownTestCase(void)
56 {
57 GTEST_LOG_(INFO) << "TearDownTestCase";
58 }
59
SetUp(void)60 void TransListenerTest::SetUp(void)
61 {
62 GTEST_LOG_(INFO) << "SetUp";
63 // Reset progress counters before each test
64 process = 0;
65 fileSize = 0;
66 }
67
TearDown(void)68 void TransListenerTest::TearDown(void)
69 {
70 GTEST_LOG_(INFO) << "TearDown";
71 }
72
73 /**
74 * @tc.name: TransListener_CopyToSandBox_0001
75 * @tc.desc: The execution of the CopyTosandbox success.
76 * @tc.type: FUNC
77 * @tc.require: I7TDJK
78 */
79 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0001, TestSize.Level0)
80 {
81 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0001 Start";
82
83 // Set up source and destination URIs with docs authority
84 string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
85 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
86
87 // Create TransListener instance with destination URI and callback
88 auto ptr = std::make_shared<TransListener>(desturi, listener);
89
90 // Execute file copy operation and verify success
91 int32_t ret = ptr->CopyToSandBox(srcuri);
92 EXPECT_EQ(ret, E_OK); // Expect operation to succeed
93
94 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0001 End";
95 }
96
97 /**
98 * @tc.name: TransListener_CopyToSandBox_0002
99 * @tc.desc: Test CopyToSandBox with media authority (should skip copy)
100 * @tc.type: FUNC
101 * @tc.require: I7TDJK
102 */
103 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0002, TestSize.Level0)
104 {
105 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0002 Start";
106
107 string srcuri = "file://media/storage/media/100/local/files/Media/src.jpg";
108 string desturi = "file://media/storage/media/100/local/files/Media/dest.jpg";
109
110 auto ptr = std::make_shared<TransListener>(desturi, listener);
111 int32_t ret = ptr->CopyToSandBox(srcuri);
112 EXPECT_EQ(ret, E_OK); // Should skip copy for media authority
113
114 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0002 End";
115 }
116
117 /**
118 * @tc.name: TransListener_CopyToSandBox_0003
119 * @tc.desc: Test CopyToSandBox directory with non-docs/media authority
120 * @tc.type: FUNC
121 * @tc.require: I7TDJK
122 */
123 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0003, TestSize.Level0)
124 {
125 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0003 Start";
126 // Setup test directory structure first
127 string testDir = "/data/storage/el2/distributedfiles/test_dir_0003";
128 std::filesystem::create_directories(testDir + "/src");
129 std::ofstream(testDir + "/src/file1.txt") << "test content";
130
131 string srcuri = "file://other" + testDir + "/src";
132 string desturi = "file://other" + testDir + "/dest";
133 auto ptr = std::make_shared<TransListener>(desturi, listener);
134
135 // change hmdfsInfo_.sandboxPath
136 ptr->hmdfsInfo_.sandboxPath = testDir + "/src";
137
138 int32_t ret = ptr->CopyToSandBox(srcuri);
139 EXPECT_EQ(ret, E_OK);
140
141 // Cleanup
142 std::filesystem::remove_all(testDir);
143 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0003 End";
144 }
145
146 /**
147 * @tc.name: TransListener_CopyToSandBox_0004
148 * @tc.desc: Test CopyToSandBox single file with non-docs/media authority
149 * @tc.type: FUNC
150 * @tc.require: I7TDJK
151 */
152 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0004, TestSize.Level0)
153 {
154 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0004 Start";
155 // Setup test file first
156 string testDir = "/data/storage/el2/distributedfiles/test_dir_0004";
157 std::filesystem::create_directories(testDir);
158 std::ofstream(testDir + "/src.txt") << "test content";
159
160 string srcuri = "file://other" + testDir + "/src.txt";
161 string desturi = "file://other" + testDir + "/dest.txt";
162 auto ptr = std::make_shared<TransListener>(desturi, listener);
163
164 // change hmdfsInfo_.sandboxPath
165 ptr->hmdfsInfo_.sandboxPath = testDir + "/src";
166
167 int32_t ret = ptr->CopyToSandBox(srcuri);
168 EXPECT_EQ(ret, EIO);
169
170 // Cleanup
171 std::filesystem::remove_all(testDir);
172 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0004 End";
173 }
174
175 /**
176 * @tc.name: TransListener_CopyToSandBox_0005
177 * @tc.desc: Test CopyToSandBox with invalid source path
178 * @tc.type: FUNC
179 * @tc.require: I7TDJK
180 */
181 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0005, TestSize.Level0)
182 {
183 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0005 Start";
184 string srcuri = "file://other/invalid/path/src.txt";
185 string desturi = "file://other/valid/path/dest.txt";
186 auto ptr = std::make_shared<TransListener>(desturi, listener);
187
188 int32_t ret = ptr->CopyToSandBox(srcuri);
189 EXPECT_EQ(ret, EIO); // Should fail with EIO
190
191 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0005 End";
192 }
193
194 /**
195 * @tc.name: TransListener_CopyToSandBox_0006
196 * @tc.desc: Test CopyToSandBox with empty source URI
197 * @tc.type: FUNC
198 * @tc.require: I7TDJK
199 */
200 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0006, TestSize.Level0)
201 {
202 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0006 Start";
203 string srcuri = "";
204 string desturi = "file://other/valid/path/dest.txt";
205 auto ptr = std::make_shared<TransListener>(desturi, listener);
206
207 int32_t ret = ptr->CopyToSandBox(srcuri);
208 EXPECT_NE(ret, E_OK); // Should fail
209
210 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0006 End";
211 }
212
213 /**
214 * @tc.name: TransListener_CopyToSandBox_0007
215 * @tc.desc: Test CopyToSandBox with permission denied scenario
216 * @tc.type: FUNC
217 * @tc.require: I7TDJK
218 */
219 HWTEST_F(TransListenerTest, TransListener_CopyToSandBox_0007, TestSize.Level0)
220 {
221 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0007 Start";
222 // Setup read-only directory
223 string testDir = "/data/storage/el2/distributedfiles/test_dir_0007";
224 std::filesystem::create_directories(testDir + "/src");
225 std::filesystem::permissions(testDir + "/src", std::filesystem::perms::owner_read,
226 std::filesystem::perm_options::replace);
227
228 string srcuri = "file://other" + testDir + "/src";
229 string desturi = "file://other" + testDir + "/dest";
230 auto ptr = std::make_shared<TransListener>(desturi, listener);
231
232 int32_t ret = ptr->CopyToSandBox(srcuri);
233 EXPECT_EQ(ret, EIO); // Should fail with EIO
234
235 // Cleanup
236 std::filesystem::permissions(testDir + "/src", std::filesystem::perms::owner_all,
237 std::filesystem::perm_options::replace);
238 std::filesystem::remove_all(testDir);
239 GTEST_LOG_(INFO) << "TransListener_CopyToSandBox_0007 End";
240 }
241
242 /**
243 * @tc.name: TransListener_Cancel_0001
244 * @tc.desc: The execution of the Cancel success.
245 * @tc.type: FUNC
246 * @tc.require: I7TDJK
247 */
248 HWTEST_F(TransListenerTest, TransListener_Cancel_0001, TestSize.Level0)
249 {
250 GTEST_LOG_(INFO) << "TransListener_Cancel_0001 Start";
251
252 // Set up test URIs
253 string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
254 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
255
256 // Create TransListener instance
257 auto ptr = std::make_shared<TransListener>(desturi, listener);
258
259 // Attempt to cancel operation and verify expected failure
260 // (Expecting failure because test environment lacks real proxy)
261 int32_t ret = ptr->Cancel(srcuri, desturi);
262 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
263
264 GTEST_LOG_(INFO) << "TransListener_Cancel_0001 End";
265 }
266
267 /**
268 * @tc.name: TransListener_OnFileReceive_0001
269 * @tc.desc: The execution of the OnFileReceive success.
270 * @tc.type: FUNC
271 * @tc.require: I7TDJK
272 */
273 HWTEST_F(TransListenerTest, TransListener_OnFileReceive_0001, TestSize.Level0)
274 {
275 GTEST_LOG_(INFO) << "TransListener_OnFileReceive_0001 Start";
276
277 // Set up test URIs
278 string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
279 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
280
281 // Create TransListener instance
282 auto ptr = std::make_shared<TransListener>(desturi, listener);
283
284 // Test file receive callback with current progress values
285 int32_t ret = ptr->OnFileReceive(process, fileSize);
286 EXPECT_EQ(ret, E_OK); // Expect callback to succeed
287
288 GTEST_LOG_(INFO) << "TransListener_OnFileReceive_0001 End";
289 }
290
291 /**
292 * @tc.name: TransListener_OnFileReceive_0002
293 * @tc.desc: The execution of the OnFileReceive failed.
294 * @tc.type: FUNC
295 * @tc.require: I7TDJK
296 */
297 HWTEST_F(TransListenerTest, TransListener_OnFileReceive_0002, TestSize.Level0)
298 {
299 GTEST_LOG_(INFO) << "TransListener_OnFileReceive_0002 Start";
300
301 // Set up test URIs
302 string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
303 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
304
305 // Create TransListener instance
306 auto ptr = std::make_shared<TransListener>(desturi, nullCallBack);
307
308 // Test file receive callback with current progress values
309 int32_t ret = ptr->OnFileReceive(process, fileSize);
310 EXPECT_EQ(ret, ENOMEM); // Expect callback to failed
311
312 GTEST_LOG_(INFO) << "TransListener_OnFileReceive_0002 End";
313 }
314
315 /**
316 * @tc.name: TransListener_0004
317 * @tc.desc: The execution of the OnFinished success.
318 * @tc.type: FUNC
319 * @tc.require: I7TDJK
320 */
321 HWTEST_F(TransListenerTest, TransListener_0004, TestSize.Level0)
322 {
323 GTEST_LOG_(INFO) << "TransListener_0004 Start";
324
325 // Set up test parameters
326 string sessionName = "test";
327 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
328
329 // Create TransListener instance
330 auto ptr = std::make_shared<TransListener>(desturi, listener);
331
332 // Simulate successful operation completion
333 int32_t ret = ptr->OnFinished(sessionName);
334 EXPECT_EQ(ret, E_OK); // Expect completion handler to succeed
335
336 GTEST_LOG_(INFO) << "TransListener_0004 End";
337 }
338
339 /**
340 * @tc.name: TransListener_0005
341 * @tc.desc: The execution of the OnFailed success.
342 * @tc.type: FUNC
343 * @tc.require: I7TDJK
344 */
345 HWTEST_F(TransListenerTest, TransListener_0005, TestSize.Level0)
346 {
347 GTEST_LOG_(INFO) << "TransListener_0005 Start";
348
349 // Set up test parameters
350 string sessionName = "test";
351 int32_t errorCode = 0; // Using 0 as generic error code for testing
352 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
353
354 // Create TransListener instance
355 auto ptr = std::make_shared<TransListener>(desturi, listener);
356
357 // Simulate operation failure
358 int32_t ret = ptr->OnFailed(sessionName, errorCode);
359 EXPECT_EQ(ret, E_OK); // Expect failure handler to succeed
360
361 GTEST_LOG_(INFO) << "TransListener_0005 End";
362 }
363
364 /**
365 * @tc.name: TransListener_0006
366 * @tc.desc: Test CreateTmpDir with docs authority.
367 * @tc.type: FUNC
368 * @tc.require: I7TDJK
369 */
370 HWTEST_F(TransListenerTest, TransListener_0006, TestSize.Level0)
371 {
372 GTEST_LOG_(INFO) << "TransListener_0006 Start";
373
374 // Set up destination URI with docs authority
375 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
376
377 // Create TransListener instance
378 auto ptr = std::make_shared<TransListener>(desturi, listener);
379
380 // Test temporary directory creation (should skip actual creation for docs)
381 int32_t ret = ptr->CreateTmpDir();
382 EXPECT_EQ(ret, E_OK); // Expect success even though no dir is created
383
384 GTEST_LOG_(INFO) << "TransListener_0006 End";
385 }
386
387 /**
388 * @tc.name: TransListener_0007
389 * @tc.desc: Test CreateTmpDir with media authority.
390 * @tc.type: FUNC
391 * @tc.require: I7TDJK
392 */
393 HWTEST_F(TransListenerTest, TransListener_0007, TestSize.Level0)
394 {
395 GTEST_LOG_(INFO) << "TransListener_0007 Start";
396
397 // Set up destination URI with media authority
398 string desturi = "file://media/storage/media/100/local/files/Media/aa1/";
399
400 // Create TransListener instance
401 auto ptr = std::make_shared<TransListener>(desturi, listener);
402
403 // Test temporary directory creation (should skip actual creation for media)
404 int32_t ret = ptr->CreateTmpDir();
405 EXPECT_EQ(ret, E_OK); // Expect success even though no dir is created
406
407 GTEST_LOG_(INFO) << "TransListener_0007 End";
408 }
409
410 /**
411 * @tc.name: TransListener_0008
412 * @tc.desc: Test CreateTmpDir with invalid path.
413 * @tc.type: FUNC
414 * @tc.require: I7TDJK
415 */
416 HWTEST_F(TransListenerTest, TransListener_0008, TestSize.Level0)
417 {
418 GTEST_LOG_(INFO) << "TransListener_0008 Start";
419
420 // Set up destination URI with invalid authority
421 string desturi = "file://invalid/storage/media/100/local/files/Invalid/aa1/";
422
423 // Create TransListener instance
424 auto ptr = std::make_shared<TransListener>(desturi, listener);
425
426 // Test temporary directory creation with invalid path
427 int32_t ret = ptr->CreateTmpDir();
428 EXPECT_EQ(ret, E_OK); // Expect failure due to invalid authority
429
430 GTEST_LOG_(INFO) << "TransListener_0008 End";
431 }
432
433 /**
434 * @tc.name: TransListener_0009
435 * @tc.desc: Test WaitForCopyResult with success result.
436 * @tc.type: FUNC
437 * @tc.require: I7TDJK
438 */
439 HWTEST_F(TransListenerTest, TransListener_0009, TestSize.Level0)
440 {
441 GTEST_LOG_(INFO) << "TransListener_0009 Start";
442
443 // Set up destination URI
444 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
445 sptr<TransListener> ptr(new (std::nothrow) TransListener(desturi, listener));
446
447 // Simulate successful completion in separate thread
__anon7298b69d0202() 448 std::thread t([ptr]() {
449 ptr->OnFinished("test_session"); // Trigger success callback
450 });
451
452 // Wait for operation result and verify success
453 int32_t ret = ptr->WaitForCopyResult();
454 t.join(); // Ensure thread completes
455 EXPECT_EQ(ret, DFS_SUCCESS); // Expect success status
456
457 GTEST_LOG_(INFO) << "TransListener_0009 End";
458 }
459
460 /**
461 * @tc.name: TransListener_0010
462 * @tc.desc: Test WaitForCopyResult with failed result.
463 * @tc.type: FUNC
464 * @tc.require: I7TDJK
465 */
466 HWTEST_F(TransListenerTest, TransListener_0010, TestSize.Level0)
467 {
468 GTEST_LOG_(INFO) << "TransListener_0010 Start";
469
470 // Set up destination URI
471 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
472 sptr<TransListener> ptr(new (std::nothrow) TransListener(desturi, listener));
473 ASSERT_TRUE(ptr != nullptr) << "ptr is nullptr!";
474
475 // Simulate failure in separate thread
__anon7298b69d0302() 476 std::thread t([ptr]() {
477 ptr->OnFailed("test_session", EIO); // Trigger failure callback
478 });
479
480 // Wait for operation result and verify failure
481 int32_t ret = ptr->WaitForCopyResult();
482 t.join(); // Ensure thread completes
483 EXPECT_EQ(ret, DFS_FAILED); // Expect failure status
484
485 GTEST_LOG_(INFO) << "TransListener_0010 End";
486 }
487
488 /**
489 * @tc.name: TransListener_0011
490 * @tc.desc: Test GetFileName with valid path.
491 * @tc.type: FUNC
492 * @tc.require: I7TDJK
493 */
494 HWTEST_F(TransListenerTest, TransListener_0011, TestSize.Level0)
495 {
496 GTEST_LOG_(INFO) << "TransListener_0011 Start";
497
498 // Set up destination URI
499 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
500 auto ptr = std::make_shared<TransListener>(desturi, listener);
501 ASSERT_TRUE(ptr != nullptr) << "ptr is nullptr!";
502
503 // Test filename extraction from valid path
504 string filename = ptr->GetFileName("/path/to/file.txt");
505 EXPECT_FALSE(filename.empty()); // Expect non-empty filename
506
507 GTEST_LOG_(INFO) << "TransListener_0011 End";
508 }
509
510 /**
511 * @tc.name: TransListener_0012
512 * @tc.desc: Test GetFileName with invalid path.
513 * @tc.type: FUNC
514 * @tc.require: I7TDJK
515 */
516 HWTEST_F(TransListenerTest, TransListener_0012, TestSize.Level0)
517 {
518 GTEST_LOG_(INFO) << "TransListener_0012 Start";
519
520 // Set up destination URI
521 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
522 auto ptr = std::make_shared<TransListener>(desturi, listener);
523
524 // Test filename extraction from invalid path
525 string filename = ptr->GetFileName("invalidpath");
526 EXPECT_TRUE(filename.empty()); // Expect empty result for invalid path
527
528 GTEST_LOG_(INFO) << "TransListener_0012 End";
529 }
530
531 /**
532 * @tc.name: TransListener_0013
533 * @tc.desc: Test GetNetworkIdFromUri with network parameter.
534 * @tc.type: FUNC
535 * @tc.require: I7TDJK
536 */
537 HWTEST_F(TransListenerTest, TransListener_0013, TestSize.Level0)
538 {
539 GTEST_LOG_(INFO) << "TransListener_0013 Start";
540
541 // Set up URI with network ID parameter
542 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/?networkid=12345";
543 auto ptr = std::make_shared<TransListener>(desturi, listener);
544
545 // Test network ID extraction
546 string networkId = ptr->GetNetworkIdFromUri(desturi);
547 EXPECT_EQ(networkId, "12345"); // Expect correct network ID extraction
548
549 GTEST_LOG_(INFO) << "TransListener_0013 End";
550 }
551
552 /**
553 * @tc.name: TransListener_0014
554 * @tc.desc: Test RmTmpDir with docs authority.
555 * @tc.type: FUNC
556 * @tc.require: I7TDJK
557 */
558 HWTEST_F(TransListenerTest, TransListener_0014, TestSize.Level0)
559 {
560 GTEST_LOG_(INFO) << "TransListener_0014 Start";
561
562 // Set up destination URI with docs authority
563 string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
564 auto ptr = std::make_shared<TransListener>(desturi, listener);
565
566 // Test temporary directory removal (should skip for docs)
567 EXPECT_NO_THROW(ptr->RmTmpDir()); // Expect no exception
568
569 GTEST_LOG_(INFO) << "TransListener_0014 End";
570 }
571
572 /**
573 * @tc.name: TransListener_0015
574 * @tc.desc: Test RmTmpDir with non-docs authority.
575 * @tc.type: FUNC
576 * @tc.require: I7TDJK
577 */
578 HWTEST_F(TransListenerTest, TransListener_0015, TestSize.Level0)
579 {
580 GTEST_LOG_(INFO) << "TransListener_0015 Start";
581
582 // Set up destination URI with non-docs authority
583 string desturi = "file://other/storage/media/100/local/files/Other/aa1/";
584 auto ptr = std::make_shared<TransListener>(desturi, listener);
585
586 // Test temporary directory removal
587 EXPECT_NO_THROW(ptr->RmTmpDir()); // Expect no exception
588
589 GTEST_LOG_(INFO) << "TransListener_0015 End";
590 }
591 } // namespace OHOS::Storage::DistributedFile::Test
