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