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 SessionManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42
43 static inline std::shared_ptr<SoftbusAdapterMock> softbusAdapterMock_ = nullptr;
44 static inline std::shared_ptr<SoftbusSessionMock> softbusSessionMock_ = nullptr;
45 };
46
SetUpTestCase(void)47 void SessionManagerTest::SetUpTestCase(void)
48 {
49 std::cout << "SetUpTestCase" << std::endl;
50 }
51
TearDownTestCase(void)52 void SessionManagerTest::TearDownTestCase(void)
53 {
54 TaskStateManager::GetInstance().CancelUnloadTask();
55 std::cout << "TearDownTestCase" << std::endl;
56 }
57
SetUp(void)58 void SessionManagerTest::SetUp(void)
59 {
60 std::cout << "SetUp" << std::endl;
61 softbusAdapterMock_ = std::make_shared<SoftbusAdapterMock>();
62 ISoftbusAdapterMock::iSoftbusAdapterMock_ = softbusAdapterMock_;
63
64 softbusSessionMock_ = std::make_shared<SoftbusSessionMock>();
65 ISoftbusSessionMock::iSoftbusSessionMock_ = softbusSessionMock_;
66 }
67
TearDown(void)68 void SessionManagerTest::TearDown(void)
69 {
70 std::cout << "TearDown" << std::endl;
71 ISoftbusAdapterMock::iSoftbusAdapterMock_ = nullptr;
72 softbusAdapterMock_ = nullptr;
73
74 ISoftbusSessionMock::iSoftbusSessionMock_ = nullptr;
75 softbusSessionMock_ = nullptr;
76 }
77
78 /**
79 * @tc.name: InitTest001
80 * @tc.desc: Verify the Init function
81 * @tc.type: FUNC
82 * @tc.require: IB3T9R
83 */
84 HWTEST_F(SessionManagerTest, InitTest001, TestSize.Level1)
85 {
86 GTEST_LOG_(INFO) << "InitTest001 start";
87 try {
88 auto sessionManager = make_shared<SessionManager>();
89 EXPECT_NE(sessionManager, nullptr);
90 EXPECT_CALL(*softbusAdapterMock_, CreateSessionServer(_, _)).WillOnce(Return(-1));
91 sessionManager->Init();
92 } catch (...) {
93 EXPECT_TRUE(false);
94 GTEST_LOG_(INFO) << "InitTest001 failed";
95 }
96 GTEST_LOG_(INFO) << "InitTest001 end";
97 }
98
99 /**
100 * @tc.name: SendDataTest001
101 * @tc.desc: Verify the SendData function
102 * @tc.type: FUNC
103 * @tc.require: IB3T9R
104 */
105 HWTEST_F(SessionManagerTest, SendDataTest001, TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "SendDataTest001 start";
108 try {
109 auto sessionManager = make_shared<SessionManager>();
110 char data[] = "test data";
111 string peerNetworkId = "test peerNetworkId";
112 EXPECT_CALL(*softbusSessionMock_, Start()).WillOnce(Return(0));
113 int32_t ret = sessionManager->SendData(peerNetworkId, data, sizeof(data));
114 EXPECT_EQ(ret, 0);
115 sessionManager->ReleaseSession(SoftbusSession::TYPE_BYTES, peerNetworkId);
116 } catch (...) {
117 EXPECT_TRUE(false);
118 GTEST_LOG_(INFO) << "SendDataTest001 failed";
119 }
120 GTEST_LOG_(INFO) << "SendDataTest001 end";
121 }
122
123 /**
124 * @tc.name: SendDataTest001
125 * @tc.desc: Verify the SendFile function
126 * @tc.type: FUNC
127 * @tc.require: IB3T9R
128 */
129 HWTEST_F(SessionManagerTest, SendFileTest001, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "SendFileTest001 start";
132 try {
133 auto sessionManager = make_shared<SessionManager>();
134 string peerNetworkId = "test peerNetworkId";
135 auto type = SoftbusSession::TYPE_BYTES;
136 auto session = make_shared<SoftbusSession>(peerNetworkId, "test session", type);
137 EXPECT_TRUE(session != nullptr);
138
139 EXPECT_CALL(*softbusSessionMock_, Start()).WillOnce(Return(0));
140 EXPECT_CALL(*softbusSessionMock_, SendFile(_, _)).WillOnce(Return(0));
141 int32_t ret = sessionManager->SendFile(peerNetworkId, {"data/test"}, {"data/test"});
142 EXPECT_EQ(ret, 0);
143 } catch (...) {
144 EXPECT_TRUE(false);
145 GTEST_LOG_(INFO) << "SendFileTest001 failed";
146 }
147 GTEST_LOG_(INFO) << "SendFileTest001 end";
148 }
149
150 /**
151 * @tc.name: OnSessionOpenedTest001
152 * @tc.desc: Verify the OnSessionOpened function
153 * @tc.type: FUNC
154 * @tc.require: IB3T9R
155 */
156 HWTEST_F(SessionManagerTest, OnSessionOpenedTest001, TestSize.Level1)
157 {
158 GTEST_LOG_(INFO) << "OnSessionOpenedTest001 start";
159 try {
160 auto sessionManager = make_shared<SessionManager>();
161 string peerNetworkId = "test peerNetworkId";
162 auto type = SoftbusSession::TYPE_BYTES;
163 auto session = make_shared<SoftbusSession>(peerNetworkId, "test session", type);
164 EXPECT_TRUE(session != nullptr);
165 int sessionId = session->GetSessionId();
166 sessionManager->OnSessionOpened(sessionId, -1);
167 } catch (...) {
168 EXPECT_TRUE(false);
169 GTEST_LOG_(INFO) << "OnSessionOpenedTest001 failed";
170 }
171 GTEST_LOG_(INFO) << "OnSessionOpenedTest001 end";
172 }
173
174 /**
175 * @tc.name: OnSessionClosedTest001
176 * @tc.desc: Verify the OnSessionClosed function
177 * @tc.type: FUNC
178 * @tc.require: IB3T9R
179 */
180 HWTEST_F(SessionManagerTest, OnSessionClosedTest001, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO) << "OnSessionClosedTest001 start";
183 try {
184 auto sessionManager = make_shared<SessionManager>();
185 string peerNetworkId = "test peerNetworkId";
186 auto type = SoftbusSession::TYPE_BYTES;
187 auto session = make_shared<SoftbusSession>(peerNetworkId, "test session", type);
188 EXPECT_TRUE(session != nullptr);
189 int sessionId = session->GetSessionId();
190 sessionManager->OnSessionClosed(sessionId);
191 } catch (...) {
192 EXPECT_TRUE(false);
193 GTEST_LOG_(INFO) << "OnSessionClosedTest001 failed";
194 }
195 GTEST_LOG_(INFO) << "OnSessionClosedTest001 end";
196 }
197
198 /**
199 * @tc.name: OnDataReceivedTest001
200 * @tc.desc: Verify the OnDataReceived function
201 * @tc.type: FUNC
202 * @tc.require: IB3T9R
203 */
204 HWTEST_F(SessionManagerTest, OnDataReceivedTest001, TestSize.Level1)
205 {
206 GTEST_LOG_(INFO) << "OnDataReceivedTest001 start";
207 try {
208 auto sessionManager = make_shared<SessionManager>();
209 char data[] = "test data";
210 string peerNetworkId = "test peerNetworkId";
211 auto type = SoftbusSession::TYPE_BYTES;
212 auto session = make_shared<SoftbusSession>(peerNetworkId, "test session", type);
213 EXPECT_TRUE(session != nullptr);
214 int sessionId = session->GetSessionId();
215 sessionManager->OnDataReceived(peerNetworkId, sessionId, data, sizeof(data));
216 EXPECT_EQ(sessionManager->dataHandler_, nullptr);
217 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
218 sessionManager->RegisterDataHandler(fileTransferManager);
219 sessionManager->OnDataReceived(peerNetworkId, sessionId, data, sizeof(data));
220 EXPECT_NE(sessionManager->dataHandler_, nullptr);
221 } catch (...) {
222 EXPECT_TRUE(false);
223 GTEST_LOG_(INFO) << "OnDataReceivedTest001 failed";
224 }
225 GTEST_LOG_(INFO) << "OnDataReceivedTest001 end";
226 }
227
228 /**
229 * @tc.name: OnFileReceivedTest001
230 * @tc.desc: Verify the OnFileReceived function
231 * @tc.type: FUNC
232 * @tc.require: IB3T9R
233 */
234 HWTEST_F(SessionManagerTest, OnFileReceivedTest001, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "OnFileReceivedTest001 start";
237 try {
238 auto sessionManager = make_shared<SessionManager>();
239 char data[] = "test data";
240 string peerNetworkId = "test peerNetworkId";
241 sessionManager->OnFileReceived(peerNetworkId, "data/test", 0);
242 EXPECT_EQ(sessionManager->dataHandler_, nullptr);
243 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
244 sessionManager->RegisterDataHandler(fileTransferManager);
245 sessionManager->OnFileReceived(peerNetworkId, "data/test", 0);
246 EXPECT_NE(sessionManager->dataHandler_, nullptr);
247 } catch (...) {
248 EXPECT_TRUE(false);
249 GTEST_LOG_(INFO) << "OnFileReceivedTest001 failed";
250 }
251 GTEST_LOG_(INFO) << "OnFileReceivedTest001 end";
252 }
253
254 /**
255 * @tc.name: OnUserUnlockedTest001
256 * @tc.desc: Verify the OnUserUnlocked function
257 * @tc.type: FUNC
258 * @tc.require: IB3T9R
259 */
260 HWTEST_F(SessionManagerTest, OnUserUnlockedTest001, TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "OnUserUnlockedTest001 start";
263 try {
264 auto sessionManager = make_shared<SessionManager>();
265 sessionManager->OnUserUnlocked();
266 EXPECT_EQ(sessionManager->dataHandler_, nullptr);
267 auto fileTransferManager = make_shared<FileTransferManager>(sessionManager);
268 sessionManager->RegisterDataHandler(fileTransferManager);
269 sessionManager->OnUserUnlocked();
270 EXPECT_NE(sessionManager->dataHandler_, nullptr);
271 } catch (...) {
272 EXPECT_TRUE(false);
273 GTEST_LOG_(INFO) << "OnUserUnlockedTest001 failed";
274 }
275 GTEST_LOG_(INFO) << "OnUserUnlockedTest001 end";
276 }
277
278 HWTEST_F(SessionManagerTest, OnUserUnlockedTest002, TestSize.Level1)
279 {
280 auto sessionManager = make_shared<SessionManager>();
281 sessionManager->SetFileRecvListenerFlag_ = false;
282 sessionManager->OnUserUnlocked();
283 EXPECT_FALSE(sessionManager->SetFileRecvListenerFlag_);
284 }
285
286 HWTEST_F(SessionManagerTest, SendFileTest002, TestSize.Level1)
287 {
288 auto sessionManager = make_shared<SessionManager>();
289 string peerNetworkId = "test peerNetworkId";
290 EXPECT_CALL(*softbusSessionMock_, Start()).WillOnce(Return(1));
291
292 int32_t ret = sessionManager->SendFile(peerNetworkId, {"data/test"}, {"data/test"});
293 EXPECT_EQ(ret, E_CREATE_SESSION);
294 }
295
296 HWTEST_F(SessionManagerTest, OnSessionClosedTest, TestSize.Level1)
297 {
298 auto sessionManager = make_shared<SessionManager>();
299
300 auto type = SoftbusSession::TYPE_BYTES;
301 string peerNetworkId = "test peerNetworkId";
302 sessionManager->ReleaseSession(type, peerNetworkId);
303
304 int32_t socket = 1;
305 sessionManager->dataHandler_ = make_shared<FileTransferManager>(nullptr);
306 sessionManager->OnSessionClosed(socket);
307 EXPECT_NE(sessionManager->dataHandler_, nullptr);
308 }
309
310 HWTEST_F(SessionManagerTest, GetSendSessionTest, TestSize.Level1)
311 {
312 auto type = SoftbusSession::TYPE_BYTES;
313 string peerNetworkId = "test peerNetworkId";
314 auto sessionManager = make_shared<SessionManager>();
315
316 auto res = sessionManager->GetSendSession(type, peerNetworkId);
317 EXPECT_EQ(res, nullptr);
318 }
319 } // namespace Test
320 } // namespace CloudSync
321 } // namespace OHOS