1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 #include "cloud_sync_common.h"
20 #include "dfs_error.h"
21 #include "file_transfer_manager.h"
22 #include "softbus_adapter_mock.h"
23 #include "softbus_session_mock.h"
24 #include "session_manager.h"
25 #include "socket_mock.h"
26 #include "task_state_manager.h"
27 #include "utils_log.h"
28
29 namespace OHOS {
30 namespace FileManagement::CloudSync {
31 namespace Test {
32 using namespace testing;
33 using namespace testing::ext;
34 using namespace std;
35
36 class FileTransferManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase(void)44 void FileTransferManagerTest::SetUpTestCase(void)
45 {
46 std::cout << "SetUpTestCase" << std::endl;
47 }
48
TearDownTestCase(void)49 void FileTransferManagerTest::TearDownTestCase(void)
50 {
51 TaskStateManager::GetInstance().CancelUnloadTask();
52 std::cout << "TearDownTestCase" << std::endl;
53 }
54
SetUp(void)55 void FileTransferManagerTest::SetUp(void)
56 {
57 std::cout << "SetUp" << std::endl;
58 }
59
TearDown(void)60 void FileTransferManagerTest::TearDown(void)
61 {
62 std::cout << "TearDown" << std::endl;
63 }
64
65 /**
66 * @tc.name: InitTest001
67 * @tc.desc: Verify the Init function
68 * @tc.type: FUNC
69 * @tc.require: IB3T5H
70 */
71 HWTEST_F(FileTransferManagerTest, InitTest001, TestSize.Level0)
72 {
73 GTEST_LOG_(INFO) << "InitTest001 start";
74 try {
75 auto sessionManager = make_shared<SessionManager>();
76 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
77 fileTransferManager->Init();
78 fileTransferManager->OnSessionClosed();
79 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
80 } catch (...) {
81 EXPECT_TRUE(false);
82 GTEST_LOG_(INFO) << "InitTest001 failed";
83 }
84 GTEST_LOG_(INFO) << "InitTest001 end";
85 }
86
87 /**
88 * @tc.name: DownloadFileFromRemoteDeviceTest001
89 * @tc.desc: Verify the DownloadFileFromRemoteDevice function
90 * @tc.type: FUNC
91 * @tc.require: IB3T5H
92 */
93 HWTEST_F(FileTransferManagerTest, DownloadFileFromRemoteDeviceTest001, TestSize.Level1)
94 {
95 GTEST_LOG_(INFO) << "DownloadFileFromRemoteDeviceTest001 start";
96 try {
97 auto sessionManager = make_shared<SessionManager>();
98 char data[] = "test data";
99 string peerNetworkId = "test peerNetworkId";
100 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
101 fileTransferManager->DownloadFileFromRemoteDevice(peerNetworkId, 0, 0, "data/test");
102 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
103 } catch (...) {
104 EXPECT_TRUE(false);
105 GTEST_LOG_(INFO) << "DownloadFileFromRemoteDeviceTest001 failed";
106 }
107 GTEST_LOG_(INFO) << "DownloadFileFromRemoteDeviceTest001 end";
108 }
109
110 /**
111 * @tc.name: DownloadFileFromRemoteDeviceTest002
112 * @tc.desc: bundleName is not empty
113 * @tc.type: FUNC
114 * @tc.require: IB3T5H
115 */
116 HWTEST_F(FileTransferManagerTest, DownloadFileFromRemoteDeviceTest002, TestSize.Level1)
117 {
118 GTEST_LOG_(INFO) << "DownloadFileFromRemoteDeviceTest002 start";
119 try {
120 auto sessionManager = make_shared<SessionManager>();
121 char data[] = "test data";
122 string peerNetworkId = "test peerNetworkId";
123 std::string uri = "file://com.ohos.a/data/storage/el2/distrubutedfiles/1.txt";
124 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
125 fileTransferManager->DownloadFileFromRemoteDevice(peerNetworkId, 0, 0, uri);
126 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
127 } catch (...) {
128 EXPECT_TRUE(false);
129 GTEST_LOG_(INFO) << "DownloadFileFromRemoteDeviceTest002 failed";
130 }
131 GTEST_LOG_(INFO) << "DownloadFileFromRemoteDeviceTest002 end";
132 }
133
134 /**
135 * @tc.name: GetBundleNameForUriTest001
136 * @tc.desc: bundleName is not empty
137 * @tc.type: FUNC
138 * @tc.require: #NA
139 */
140 HWTEST_F(FileTransferManagerTest, GetBundleNameForUriTest001, TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "GetBundleNameForUriTest001 start";
143 try {
144 auto sessionManager = make_shared<SessionManager>();
145 std::string uri = "file://com.ohos.a/data/storage/el2/distrubutedfiles/1.txt";
146 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
147 auto bundleName = fileTransferManager->GetBundleNameForUri(uri);
148 EXPECT_EQ(bundleName, "com.ohos.a");
149 } catch (...) {
150 EXPECT_TRUE(false);
151 GTEST_LOG_(INFO) << "GetBundleNameForUriTest001 failed";
152 }
153 GTEST_LOG_(INFO) << "GetBundleNameForUriTest001 end";
154 }
155
156 /**
157 * @tc.name: GetBundleNameForUriTest002
158 * @tc.desc: bundleName is empty
159 * @tc.type: FUNC
160 * @tc.require: #NA
161 */
162 HWTEST_F(FileTransferManagerTest, GetBundleNameForUriTest002, TestSize.Level1)
163 {
164 GTEST_LOG_(INFO) << "GetBundleNameForUriTest002 start";
165 try {
166 auto sessionManager = make_shared<SessionManager>();
167 std::string uri = "data/";
168 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
169 auto bundleName = fileTransferManager->GetBundleNameForUri(uri);
170 EXPECT_TRUE(bundleName.empty());
171 } catch (...) {
172 EXPECT_TRUE(false);
173 GTEST_LOG_(INFO) << "GetBundleNameForUriTest002 failed";
174 }
175 GTEST_LOG_(INFO) << "GetBundleNameForUriTest002 end";
176 }
177
178 /**
179 * @tc.name: GetBundleNameForUriTest003
180 * @tc.desc: bundleName is empty
181 * @tc.type: FUNC
182 * @tc.require: #NA
183 */
184 HWTEST_F(FileTransferManagerTest, GetBundleNameForUriTest003, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "GetBundleNameForUriTest003 start";
187 try {
188 auto sessionManager = make_shared<SessionManager>();
189 std::string uri = "file://com.ohos.a";
190 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
191 auto bundleName = fileTransferManager->GetBundleNameForUri(uri);
192 EXPECT_TRUE(bundleName.empty());
193 } catch (...) {
194 EXPECT_TRUE(false);
195 GTEST_LOG_(INFO) << "GetBundleNameForUriTest003 failed";
196 }
197 GTEST_LOG_(INFO) << "GetBundleNameForUriTest003 end";
198 }
199 /**
200 * @tc.name: OnMessageHandleTest001
201 * @tc.desc: Verify the OnMessageHandle function
202 * @tc.type: FUNC
203 * @tc.require: IB3T5H
204 */
205 HWTEST_F(FileTransferManagerTest, OnMessageHandleTest001, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "OnMessageHandleTest001 start";
208 try {
209 auto sessionManager = make_shared<SessionManager>();
210 char data[] = "test data";
211 string peerNetworkId = "test peerNetworkId";
212 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
213 fileTransferManager->OnMessageHandle(peerNetworkId, 0, data, sizeof(data));
214 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
215 } catch (...) {
216 EXPECT_TRUE(false);
217 GTEST_LOG_(INFO) << "OnMessageHandleTest001 failed";
218 }
219 GTEST_LOG_(INFO) << "OnMessageHandleTest001 end";
220 }
221
222 /**
223 * @tc.name: HandleDownloadFileRequestTest001
224 * @tc.desc: Verify the HandleDownloadFileRequest function
225 * @tc.type: FUNC
226 * @tc.require: IB3T5H
227 */
228 HWTEST_F(FileTransferManagerTest, HandleDownloadFileRequestTest001, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "HandleDownloadFileRequestTest001 start";
231 try {
232 auto sessionManager = make_shared<SessionManager>();
233 char data[] = "test data";
234 string peerNetworkId = "test peerNetworkId";
235 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
236
237 MessageInputInfo msgInputInfo = {};
238 msgInputInfo.userId = 100;
239 msgInputInfo.taskId = 100;
240 msgInputInfo.uri = "data/test";
241 msgInputInfo.errorCode = E_OK;
242 MessageHandler msgHandle(msgInputInfo);
243 fileTransferManager->HandleDownloadFileRequest(msgHandle, peerNetworkId, 0);
244 fileTransferManager->HandleDownloadFileResponse(msgHandle);
245 fileTransferManager->HandleRecvFileFinished();
246 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
247 } catch (...) {
248 EXPECT_TRUE(false);
249 GTEST_LOG_(INFO) << "HandleDownloadFileRequestTest001 failed";
250 }
251 GTEST_LOG_(INFO) << "HandleDownloadFileRequestTest001 end";
252 }
253
254 /**
255 * @tc.name: HandleDownloadFileRequestTest001
256 * @tc.desc: Verify the HandleDownloadFileRequest function have errorCode
257 * @tc.type: FUNC
258 * @tc.require: IB3T5H
259 */
260 HWTEST_F(FileTransferManagerTest, HandleDownloadFileRequestTest002, TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "HandleDownloadFileRequestTest001 start";
263 try {
264 auto sessionManager = make_shared<SessionManager>();
265 char data[] = "test data";
266 string peerNetworkId = "test peerNetworkId";
267 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
268
269 MessageInputInfo msgInputInfo = {};
270 msgInputInfo.userId = 100;
271 msgInputInfo.taskId = 100;
272 msgInputInfo.uri = "data/test";
273 msgInputInfo.errorCode = 1;
274 MessageHandler msgHandle(msgInputInfo);
275 fileTransferManager->HandleDownloadFileRequest(msgHandle, peerNetworkId, 0);
276 fileTransferManager->HandleDownloadFileResponse(msgHandle);
277 fileTransferManager->HandleRecvFileFinished();
278 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
279 } catch (...) {
280 EXPECT_TRUE(false);
281 GTEST_LOG_(INFO) << "HandleDownloadFileRequestTest001 failed";
282 }
283 GTEST_LOG_(INFO) << "HandleDownloadFileRequestTest001 end";
284 }
285
286 /**
287 * @tc.name: IsFileExistsTest001
288 * @tc.desc: Verify the IsFileExists function
289 * @tc.type: FUNC
290 * @tc.require: IB3T5H
291 */
292 HWTEST_F(FileTransferManagerTest, IsFileExistsTest001, TestSize.Level1)
293 {
294 GTEST_LOG_(INFO) << "IsFileExistsTest001 start";
295 try {
296 auto sessionManager = make_shared<SessionManager>();
297 char data[] = "test data";
298 string peerNetworkId = "test peerNetworkId";
299 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
300 EXPECT_TRUE(fileTransferManager->IsFileExists("data/errorPath") == false);
301 } catch (...) {
302 EXPECT_TRUE(false);
303 GTEST_LOG_(INFO) << "IsFileExistsTest001 failed";
304 }
305 GTEST_LOG_(INFO) << "IsFileExistsTest001 end";
306 }
307
308 /**
309 * @tc.name: AddTransTaskTest001
310 * @tc.desc: Verify the AddTransTask function
311 * @tc.type: FUNC
312 * @tc.require: IB3T5H
313 */
314 HWTEST_F(FileTransferManagerTest, AddTransTaskTest001, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO) << "AddTransTaskTest001 start";
317 try {
318 auto sessionManager = make_shared<SessionManager>();
319 char data[] = "test data";
320 string peerNetworkId = "test peerNetworkId";
321 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
322 fileTransferManager->AddTransTask("data/test", 0, 100);
323 fileTransferManager->FinishTransTask("data/test", 0);
324 fileTransferManager->RemoveTransTask(100);
325 EXPECT_NE(fileTransferManager->sessionManager_, nullptr);
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << "AddTransTaskTest001 failed";
329 }
330 GTEST_LOG_(INFO) << "AddTransTaskTest001 end";
331 }
332
333 /**
334 * @tc.name: UriToPathTest001
335 * @tc.desc: Invalid uri
336 * @tc.type: FUNC
337 * @tc.require: IB3T5H
338 */
339 HWTEST_F(FileTransferManagerTest, UriToPathTest001, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "UriToPathTest001 start";
342 try {
343 auto sessionManager = make_shared<SessionManager>();
344 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
345 auto [first, second] = fileTransferManager->UriToPath("data/test", 100, false);
346 EXPECT_TRUE(first.empty());
347 EXPECT_TRUE(second.empty());
348 } catch (...) {
349 EXPECT_TRUE(false);
350 GTEST_LOG_(INFO) << "UriToPathTest001 failed";
351 }
352 GTEST_LOG_(INFO) << "UriToPathTest001 end";
353 }
354
355 /**
356 * @tc.name: UriToPathTest002
357 * @tc.desc: Verify the UriToPath function
358 * @tc.type: FUNC
359 * @tc.require: IB3T5H
360 */
361 HWTEST_F(FileTransferManagerTest, UriToPathTest002, TestSize.Level1)
362 {
363 GTEST_LOG_(INFO) << "UriToPathTest002 start";
364 try {
365 auto sessionManager = make_shared<SessionManager>();
366 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
367 std::string uri = "file://com.ohos.a/data/storage/el2/distributedfiles/1.txt";
368 std::string relativePath = "/1.txt";
369 auto [first, second] = fileTransferManager->UriToPath(uri, 100, false);
370 EXPECT_EQ(second, relativePath);
371 } catch (...) {
372 EXPECT_TRUE(false);
373 GTEST_LOG_(INFO) << "UriToPathTest002 failed";
374 }
375 GTEST_LOG_(INFO) << "UriToPathTest002 end";
376 }
377 } // namespace Test
378 } // namespace CloudSync
379 } // namespace OHOS