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 "softbus_adapter.h"
22 #include "session_manager.h"
23 #include "softbus_session.h"
24 #include "socket_mock.h"
25 #include "utils_log.h"
26
27 namespace OHOS {
28 namespace FileManagement::CloudSync {
29 namespace Test {
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace std;
33
34 class SoftbusAdapterTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 static inline shared_ptr<Storage::DistributedFile::SocketMock> socketMock_ = nullptr;
41 };
42
SetUpTestCase(void)43 void SoftbusAdapterTest::SetUpTestCase(void)
44 {
45 std::cout << "SetUpTestCase" << std::endl;
46 socketMock_ = make_shared<Storage::DistributedFile::SocketMock>();
47 Storage::DistributedFile::SocketMock::dfsSocket = socketMock_;
48 }
49
TearDownTestCase(void)50 void SoftbusAdapterTest::TearDownTestCase(void)
51 {
52 std::cout << "TearDownTestCase" << std::endl;
53 Storage::DistributedFile::SocketMock::dfsSocket = nullptr;
54 socketMock_ = nullptr;
55 }
56
SetUp(void)57 void SoftbusAdapterTest::SetUp(void)
58 {
59 std::cout << "SetUp" << std::endl;
60 }
61
TearDown(void)62 void SoftbusAdapterTest::TearDown(void)
63 {
64 std::cout << "TearDown" << std::endl;
65 }
66
67 /**
68 * @tc.name: CreateSessionServerTest001
69 * @tc.desc: Verify the CreateSessionServer function
70 * @tc.type: FUNC
71 * @tc.require: IB3T80
72 */
73 HWTEST_F(SoftbusAdapterTest, CreateSessionServerTest001, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "CreateSessionServerTest001 start";
76 try {
77 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
78 char packageName[] = "com.example.test";
79 char sessionName[] = "testSession";
80 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
81 int32_t result = adapter.CreateSessionServer(packageName, sessionName);
82 EXPECT_EQ(result, ERR_BAD_VALUE);
83 } catch (...) {
84 EXPECT_TRUE(false);
85 GTEST_LOG_(INFO) << "CreateSessionServerTest001 failed";
86 }
87 GTEST_LOG_(INFO) << "CreateSessionServerTest001 end";
88 }
89
90 /**
91 * @tc.name: CreateSessionServerTest002
92 * @tc.desc: Verify the CreateSessionServer function
93 * @tc.type: FUNC
94 * @tc.require: IB3T80
95 */
96 HWTEST_F(SoftbusAdapterTest, CreateSessionServerTest002, TestSize.Level1)
97 {
98 GTEST_LOG_(INFO) << "CreateSessionServerTest002 start";
99 try {
100 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
101 char packageName[] = "com.example.test";
102 char sessionName[] = "testSession";
103
104 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
105 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(0));
106 int32_t result = adapter.CreateSessionServer(packageName, sessionName);
107 EXPECT_EQ(result, E_OK);
108 adapter.RemoveSessionServer(packageName, sessionName);
109 } catch (...) {
110 EXPECT_TRUE(false);
111 GTEST_LOG_(INFO) << "CreateSessionServerTest002 failed";
112 }
113 GTEST_LOG_(INFO) << "CreateSessionServerTest002 end";
114 }
115
116 /**
117 * @tc.name: CreateSessionServerTest003
118 * @tc.desc: Verify the CreateSessionServer function
119 * @tc.type: FUNC
120 * @tc.require: IB3T80
121 */
122 HWTEST_F(SoftbusAdapterTest, CreateSessionServerTest003, TestSize.Level1)
123 {
124 GTEST_LOG_(INFO) << "CreateSessionServerTest003 start";
125 try {
126 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
127 char packageName[] = "com.example.test";
128 char sessionName[] = "testSession";
129
130 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
131 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(1));
132 int32_t result = adapter.CreateSessionServer(packageName, sessionName);
133 EXPECT_EQ(result, 1);
134 adapter.RemoveSessionServer(packageName, sessionName);
135 } catch (...) {
136 EXPECT_TRUE(false);
137 GTEST_LOG_(INFO) << "CreateSessionServerTest003 failed";
138 }
139 GTEST_LOG_(INFO) << "CreateSessionServerTest003 end";
140 }
141
142 /**
143 * @tc.name: OpenSessionByP2PTest001
144 * @tc.desc: Verify the OpenSessionByP2P function
145 * @tc.type: FUNC
146 * @tc.require: IB3T80
147 */
148 HWTEST_F(SoftbusAdapterTest, OpenSessionByP2PTest001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "OpenSessionByP2PTest001 start";
151 try {
152 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
153 char sessionName[] = "testSession";
154 char peerNetworkId[] = "test peerNetworkId";
155 char groupId[] = "test";
156
157 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
158 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, true);
159 EXPECT_EQ(socketFd, ERR_BAD_VALUE);
160
161 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
162 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
163 socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, true);
164 EXPECT_EQ(socketFd, 1);
165 CloseSession(socketFd);
166 } catch (...) {
167 EXPECT_TRUE(false);
168 GTEST_LOG_(INFO) << "OpenSessionByP2PTest001 failed";
169 }
170 GTEST_LOG_(INFO) << "OpenSessionByP2PTest001 end";
171 }
172
173 /**
174 * @tc.name: OpenSessionByP2PTest002
175 * @tc.desc: Verify the OpenSessionByP2P function
176 * @tc.type: FUNC
177 * @tc.require: IB3T80
178 */
179 HWTEST_F(SoftbusAdapterTest, OpenSessionByP2PTest002, TestSize.Level1)
180 {
181 GTEST_LOG_(INFO) << "OpenSessionByP2PTest002 start";
182 try {
183 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
184 char sessionName[] = "testSession";
185 char peerNetworkId[] = "test peerNetworkId";
186 char groupId[] = "test";
187
188 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
189 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
190 EXPECT_EQ(socketFd, ERR_BAD_VALUE);
191
192 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
193 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
194 socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
195 EXPECT_EQ(socketFd, 1);
196 CloseSession(socketFd);
197 } catch (...) {
198 EXPECT_TRUE(false);
199 GTEST_LOG_(INFO) << "OpenSessionByP2PTest002 failed";
200 }
201 GTEST_LOG_(INFO) << "OpenSessionByP2PTest002 end";
202 }
203
204 /**
205 * @tc.name: EventTest001
206 * @tc.desc: Verify the OpenSessionByP2P function
207 * @tc.type: FUNC
208 * @tc.require: IB3T80
209 */
210 HWTEST_F(SoftbusAdapterTest, EventTest001, TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "EventTest001 start";
213 try {
214 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
215 char sessionName[] = "testSession";
216 char peerNetworkId[] = "test peerNetworkId";
217 char groupId[] = "test";
218 PeerSocketInfo info;
219 info.name = sessionName;
220 info.networkId = peerNetworkId;
221
222 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
223 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
224 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
225 // OnBind
226 SoftbusAdapter::OnBind(socketFd, info);
227 // OnShutdown
228 SoftbusAdapter::OnShutdown(socketFd, SHUTDOWN_REASON_UNKNOWN);
229 // OnBytes
230 char data[] = "test data";
231 SoftbusAdapter::OnBytes(socketFd, data, sizeof(data));
232 // OnFile
233 FileEvent event;
234 event.type = FileEventType::FILE_EVENT_RECV_UPDATE_PATH;
235 SoftbusAdapter::OnFile(socketFd, &event);
236 // OnReceiveFileProcess
237 int32_t result = SoftbusAdapter::OnReceiveFileProcess(socketFd, "", 0, 0);
238 EXPECT_EQ(result, 0);
239 // OnReceiveFileFinished
240 SoftbusAdapter::OnReceiveFileFinished(socketFd, "", 0);
241 SoftbusAdapter::pathDir_ = "/mnt/hmdfs/100/account/device_view/local/data/com.ohos.a";
242 std::string res = std::string(SoftbusAdapter::GetRecvPath());
243 // GetRecvPath
244 EXPECT_EQ(res, "/mnt/hmdfs/100/account/device_view/local/data/com.ohos.a");
245 } catch (...) {
246 EXPECT_TRUE(false);
247 GTEST_LOG_(INFO) << "EventTest001 failed";
248 }
249 GTEST_LOG_(INFO) << "EventTest001 end";
250 }
251
252 /**
253 * @tc.name: SendFileTest001
254 * @tc.desc: Verify the OpenSessionByP2P function
255 * @tc.type: FUNC
256 * @tc.require: IB3T80
257 */
258 HWTEST_F(SoftbusAdapterTest, SendFileTest001, TestSize.Level1)
259 {
260 GTEST_LOG_(INFO) << "SendFileTest001 start";
261 try {
262 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
263 char sessionName[] = "testSession";
264 char peerNetworkId[] = "test peerNetworkId";
265 char groupId[] = "test";
266 char data[] = "test data";
267
268 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
269 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
270 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
271 int result = adapter.SendFile(socketFd, {"data/test"}, {"data/test"});
272 EXPECT_EQ(result, 0);
273 } catch (...) {
274 EXPECT_TRUE(false);
275 GTEST_LOG_(INFO) << "SendFileTest001 failed";
276 }
277 GTEST_LOG_(INFO) << "SendFileTest001 end";
278 }
279
280 /**
281 * @tc.name: GetSessionNameTest001
282 * @tc.desc: Verify the OpenSessionByP2P function
283 * @tc.type: FUNC
284 * @tc.require: IB3T80
285 */
286 HWTEST_F(SoftbusAdapterTest, GetSessionNameTest001, TestSize.Level1)
287 {
288 GTEST_LOG_(INFO) << "GetSessionNameTest001 start";
289 try {
290 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
291 char sessionName[] = "testSession";
292 char peerNetworkId[] = "test peerNetworkId";
293 char groupId[] = "test";
294 char data[] = "test data";
295
296 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
297 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
298 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
299
300 EXPECT_EQ(adapter.GetSessionNameFromMap(socketFd), "testSession");
301 EXPECT_EQ(adapter.GetPeerNetworkId(socketFd), "test peerNetworkId");
302 EXPECT_EQ(adapter.GetSocketNameFromMap("testSession"), -1);
303 } catch (...) {
304 EXPECT_TRUE(false);
305 GTEST_LOG_(INFO) << "GetSessionNameTest001 failed";
306 }
307 GTEST_LOG_(INFO) << "GetSessionNameTest001 end";
308 }
309
310 /**
311 * @tc.name: RegisterSessionTest001
312 * @tc.desc: Verify the OpenSessionByP2P function
313 * @tc.type: FUNC
314 * @tc.require: IB3T80
315 */
316 HWTEST_F(SoftbusAdapterTest, RegisterSessionTest001, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO) << "RegisterSessionTest001 start";
319 try {
320 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
321 char sessionName[] = "testSession";
322 char peerNetworkId[] = "test peerNetworkId";
323 char groupId[] = "test";
324 char data[] = "test data";
325
326 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
327 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
328 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
329
330 adapter.RegisterSessionListener(sessionName, nullptr);
331 adapter.UnRegisterSessionListener(sessionName);
332 EXPECT_EQ(adapter.IsSessionOpened(socketFd), true);
333
334 adapter.AcceptSesion(socketFd, sessionName, peerNetworkId);
335 adapter.RemoveSesion(socketFd);
336 } catch (...) {
337 EXPECT_TRUE(false);
338 GTEST_LOG_(INFO) << "RegisterSessionTest001 failed";
339 }
340 GTEST_LOG_(INFO) << "RegisterSessionTest001 end";
341 }
342
343 HWTEST_F(SoftbusAdapterTest, RemoveSessionServerTest001, TestSize.Level1)
344 {
345 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
346
347 char packageName[] = "";
348 char sessionName[] = "";
349
350 int32_t res = adapter.RemoveSessionServer(packageName, sessionName);
351 EXPECT_EQ(res, E_OK);
352 }
353
354 HWTEST_F(SoftbusAdapterTest, OnBindTest001, TestSize.Level1)
355 {
356 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
357
358 int socket = 1;
359 char sessionName[] = "";
360 char peerNetworkId[] = "test peerNetworkId";
361 PeerSocketInfo info;
362 info.name = sessionName;
363 info.networkId = peerNetworkId;
364
365 adapter.OnBind(socket, info);
366 EXPECT_EQ(info.name, sessionName);
367
368 auto ptr = std::make_shared<SessionManager>();
369 (adapter.listeners_)["socket"] = ptr;
370 char socket2[] = "socket";
371 info.name = socket2;
372 adapter.OnBind(socket, info);
373 EXPECT_NE(adapter.listeners_.count("socket"), 0);
374 adapter.listeners_.erase("socket");
375 }
376
377 HWTEST_F(SoftbusAdapterTest, OnShutdownTest, TestSize.Level1)
378 {
379 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
380
381 int32_t socket = 0;
382 ShutdownReason reason = ShutdownReason::SHUTDOWN_REASON_UNKNOWN;
383 adapter.OnShutdown(socket, reason);
384
385 (adapter.sessionNameMap_)[0] = "test";
386 auto ptr = std::make_shared<SessionManager>();
387 (adapter.listeners_)["test"] = ptr;
388 adapter.OnShutdown(socket, reason);
389 EXPECT_NE(adapter.listeners_.count("test"), 0);
390 adapter.listeners_.erase("test");
391 }
392
393 HWTEST_F(SoftbusAdapterTest, OnBytesTest, TestSize.Level1)
394 {
395 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
396
397 int socket = 0;
398 unsigned int dataLen = 1;
399 adapter.OnBytes(socket, nullptr, dataLen);
400
401 (adapter.sessionNameMap_)[0] = "test";
402 adapter.OnBytes(socket, nullptr, dataLen);
403
404 (adapter.networkIdMap_)[0] = "test";
405 auto ptr = std::make_shared<SessionManager>();
406 (adapter.listeners_)["test"] = ptr;
407 adapter.OnBytes(socket, nullptr, dataLen);
408
409 EXPECT_NE(adapter.listeners_.count("test"), 0);
410 adapter.listeners_.erase("test");
411 }
412
413 HWTEST_F(SoftbusAdapterTest, OnReceiveFileFinishedTest, TestSize.Level1)
414 {
415 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
416
417 int sessionId = -1;
418 char *files = nullptr;
419 int fileCnt = 1;
420 adapter.OnReceiveFileFinished(sessionId, files, fileCnt);
421
422 (adapter.sessionNameMap_)[-1] = "test1";
423 adapter.OnReceiveFileFinished(sessionId, files, fileCnt);
424
425 (adapter.networkIdMap_)[-1] = "test2";
426 auto ptr = std::make_shared<SessionManager>();
427 (adapter.listeners_)["test1"] = ptr;
428 adapter.OnReceiveFileFinished(sessionId, files, fileCnt);
429
430 EXPECT_NE(adapter.listeners_.count("test1"), 0);
431 adapter.listeners_.erase("test1");
432 }
433
434 HWTEST_F(SoftbusAdapterTest, OpenSessionTest, TestSize.Level1)
435 {
436 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
437
438 TransDataType dataType = TransDataType::DATA_TYPE_MESSAGE;
439 char sessionName[] = "";
440 char peerDeviceId[] = "";
441 char groupId[] = "";
442 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
443 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(1));
444
445 auto res = adapter.OpenSession(sessionName, peerDeviceId, groupId, dataType);
446 EXPECT_EQ(res, 1);
447 }
448
449 HWTEST_F(SoftbusAdapterTest, GetPeerNetworkIdTest, TestSize.Level1)
450 {
451 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
452
453 TransDataType dataType = TransDataType::DATA_TYPE_MESSAGE;
454 char sessionName[] = "";
455 char peerDeviceId[] = "";
456 char groupId[] = "";
457 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
458 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(1));
459
460 auto res = adapter.OpenSession(sessionName, peerDeviceId, groupId, dataType);
461 EXPECT_EQ(res, 1);
462 }
463
464 /**
465 * @tc.name: UpdateFileRecvPathTest001
466 * @tc.desc: Verify the UpdateFileRecvPath function
467 * @tc.type: FUNC
468 * @tc.require: #NA
469 */
470 HWTEST_F(SoftbusAdapterTest, UpdateFileRecvPathTest001, TestSize.Level1)
471 {
472 SoftbusAdapter &adapter = SoftbusAdapter::GetInstance();
473
474 std::string bundleName = "com.ohos.a";
475 int32_t userId = 100;
476 SoftbusAdapter::UpdateFileRecvPath(bundleName, userId);
477 std::string res = "/mnt/hmdfs/100/account/device_view/local/data/com.ohos.a";
478 EXPECT_EQ(adapter.pathDir_, res);
479 }
480 } // namespace Test
481 } // namespace CloudSync
482 } // namespace OHOS