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 <memory>
18 
19 #include "ISessionListener.h"
20 #include "softbus_error_code.h"
21 #include "session_impl.h"
22 #include "session_mock.h"
23 #include "session_service_impl.h"
24 
25 using namespace testing;
26 
27 using namespace testing::ext;
28 
29 namespace Communication {
30 namespace SoftBus {
31 
32 class SessionListenerImpl : public ISessionListener {
33 public:
34     SessionListenerImpl() = default;
35     ~SessionListenerImpl() = default;
36 
OnSessionOpened(std::shared_ptr<Session> session)37     int32_t OnSessionOpened(std::shared_ptr<Session> session) override
38     {
39         return SOFTBUS_OK;
40     }
41 
OnSessionClosed(std::shared_ptr<Session> session)42     void OnSessionClosed(std::shared_ptr<Session> session) override
43     {
44         return;
45     }
46 
OnMessageReceived(std::shared_ptr<Session> session,const char * data,ssize_t len)47     void OnMessageReceived(std::shared_ptr<Session> session, const char *data, ssize_t len) override
48     {
49         return;
50     }
51 
OnBytesReceived(std::shared_ptr<Session> session,const char * data,ssize_t len)52     void OnBytesReceived(std::shared_ptr<Session> session, const char *data, ssize_t len) override
53     {
54         return;
55     }
56 
OnDataAvailable(std::shared_ptr<Session> session,uint32_t status)57     bool OnDataAvailable(std::shared_ptr<Session> session, uint32_t status) override
58     {
59         return true;
60     }
61 };
62 
63 class TransClientSessionServiceImplTest : public testing::Test {
64 public:
65     TransClientSessionServiceImplTest() = default;
66     ~TransClientSessionServiceImplTest() = default;;
67 
68     static void SetUpTestCase(void);
69     static void TearDownTestCase(void);
SetUp()70     void SetUp() override
71     {}
TearDown()72     void TearDown() override
73     {}
74 };
75 
SetUpTestCase(void)76 void TransClientSessionServiceImplTest::SetUpTestCase(void) {}
77 
TearDownTestCase(void)78 void TransClientSessionServiceImplTest::TearDownTestCase(void) {}
79 
80 /**
81  * @tc.name: CreateSessionServer001
82  * @tc.desc: Test when pkgName is empty then CreateSessionServer returns SOFTBUS_INVALID_PARAM.
83  * @tc.type: FUNC
84  * @tc.require:
85  */
86 HWTEST_F(TransClientSessionServiceImplTest, CreateSessionServer001, TestSize.Level0)
87 {
88     std::string pkgName = "";
89     std::string sessionName = "testSession";
90     std::shared_ptr<SessionListenerImpl> listener = std::make_shared<SessionListenerImpl>();
91     SessionServiceImpl sessionServiceImpl;
92     int32_t ret = sessionServiceImpl.CreateSessionServer(pkgName, sessionName, listener);
93     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
94 }
95 
96 /**
97  * @tc.name: CreateSessionServer002
98  * @tc.desc: Test when sessionName is empty then CreateSessionServer returns SOFTBUS_INVALID_PARAM.
99  * @tc.type: FUNC
100  * @tc.require:
101  */
102 HWTEST_F(TransClientSessionServiceImplTest, CreateSessionServer002, TestSize.Level0)
103 {
104     std::string pkgName = "testPkg";
105     std::string sessionName = "";
106     std::shared_ptr<SessionListenerImpl> listener = std::make_shared<SessionListenerImpl>();
107     SessionServiceImpl sessionServiceImpl;
108     int32_t ret = sessionServiceImpl.CreateSessionServer(pkgName, sessionName, listener);
109     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
110 }
111 
112 /**
113  * @tc.name: CreateSessionServer003
114  * @tc.desc: Test when listener is nullptr then CreateSessionServer returns SOFTBUS_INVALID_PARAM.
115  * @tc.type: FUNC
116  * @tc.require:
117  */
118 HWTEST_F(TransClientSessionServiceImplTest, CreateSessionServer003, TestSize.Level0)
119 {
120     std::string pkgName = "testPkg";
121     std::string sessionName = "testSession";
122     SessionServiceImpl sessionServiceImpl;
123     int32_t ret = sessionServiceImpl.CreateSessionServer(pkgName, sessionName, nullptr);
124     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
125 }
126 
127 /**
128  * @tc.name: RemoveSessionServer001
129  * @tc.desc: Test when pkgName or sessionName is empty then RemoveSessionServer returns SOFTBUS_INVALID_PARAM
130  * @tc.type: FUNC
131  * @tc.require:
132  */
133 HWTEST_F(TransClientSessionServiceImplTest, RemoveSessionServer001, TestSize.Level0)
134 {
135     SessionServiceImpl sessionServiceImpl;
136     int32_t result = sessionServiceImpl.RemoveSessionServer("", "sessionName");
137     EXPECT_EQ(result, SOFTBUS_INVALID_PARAM);
138     result = sessionServiceImpl.RemoveSessionServer("pkgName", "");
139     EXPECT_EQ(result, SOFTBUS_INVALID_PARAM);
140 }
141 
142 /**
143  * @tc.name: RemoveSessionServer002
144  * @tc.desc: Test when sessionName not found in listenerMap_.
145  * @tc.type: FUNC
146  * @tc.require:
147  */
148 HWTEST_F(TransClientSessionServiceImplTest, RemoveSessionServer002, TestSize.Level0)
149 {
150     SessionServiceImpl sessionServiceImpl;
151     int32_t result = sessionServiceImpl.RemoveSessionServer("pkgName", "notFoundSessionName");
152     EXPECT_EQ(result, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
153 }
154 
155 /**
156  * @tc.name: OpenSession001
157  * @tc.desc: Test when mySessionName is empty then OpenSession returns nullptr.
158  * @tc.type: FUNC
159  * @tc.require:
160  */
161 HWTEST_F(TransClientSessionServiceImplTest, OpenSession001, TestSize.Level0)
162 {
163     std::string mySessionName = "";
164     std::string peerSessionName = "peerSessionName";
165     std::string peerNetworkId = "peerNetworkId";
166     std::string groupId = "groupId";
167     int32_t flags = 0;
168     SessionServiceImpl sessionServiceImpl;
169     std::shared_ptr<Session> session =
170         sessionServiceImpl.OpenSession(mySessionName, peerSessionName, peerNetworkId, groupId, flags);
171     EXPECT_EQ(session, nullptr);
172 }
173 
174 /**
175  * @tc.name: OpenSession002
176  * @tc.desc: Test when peerSessionName is empty then OpenSession returns nullptr.
177  * @tc.type: FUNC
178  * @tc.require:
179  */
180 HWTEST_F(TransClientSessionServiceImplTest, OpenSession002, TestSize.Level0)
181 {
182     std::string mySessionName = "mySessionName";
183     std::string peerSessionName = "";
184     std::string peerNetworkId = "peerNetworkId";
185     std::string groupId = "groupId";
186     int32_t flags = 0;
187     SessionServiceImpl sessionServiceImpl;
188     std::shared_ptr<Session> session =
189         sessionServiceImpl.OpenSession(mySessionName, peerSessionName, peerNetworkId, groupId, flags);
190     EXPECT_EQ(session, nullptr);
191 }
192 
193 /**
194  * @tc.name: OpenSession003
195  * @tc.desc: Test when peerNetworkId is empty then OpenSession returns nullptr.
196  * @tc.type: FUNC
197  * @tc.require:
198  */
199 HWTEST_F(TransClientSessionServiceImplTest, OpenSession003, TestSize.Level0)
200 {
201     std::string mySessionName = "mySessionName";
202     std::string peerSessionName = "peerSessionName";
203     std::string peerNetworkId = "";
204     std::string groupId = "groupId";
205     int32_t flags = 0;
206     SessionServiceImpl sessionServiceImpl;
207     std::shared_ptr<Session> session =
208         sessionServiceImpl.OpenSession(mySessionName, peerSessionName, peerNetworkId, groupId, flags);
209     EXPECT_EQ(session, nullptr);
210 }
211 
212 /**
213  * @tc.name: OpenSession004
214  * @tc.desc: Test when OpenSessionInner returns a value less than or equal to 0 then OpenSession returns nullptr.
215  * @tc.type: FUNC
216  * @tc.require:
217  */
218 HWTEST_F(TransClientSessionServiceImplTest, OpenSession004, TestSize.Level0)
219 {
220     std::string mySessionName = "mySessionName";
221     std::string peerSessionName = "peerSessionName";
222     std::string peerNetworkId = "peerNetworkId";
223     std::string groupId = "groupId";
224     int32_t flags = 0;
225     SessionServiceImpl sessionServiceImpl;
226     std::shared_ptr<Session> session =
227         sessionServiceImpl.OpenSession(mySessionName, peerSessionName, peerNetworkId, groupId, flags);
228     EXPECT_EQ(session, nullptr);
229 }
230 
231 /**
232  * @tc.name: CloseSession001
233  * @tc.desc: Test when session is nullptr then CloseSession returns SOFTBUS_INVALID_PARAM.
234  * @tc.type: FUNC
235  * @tc.require:
236  */
237 HWTEST_F(TransClientSessionServiceImplTest, CloseSession001, TestSize.Level0)
238 {
239     SessionServiceImpl sessionServiceImpl;
240     int32_t ret = sessionServiceImpl.CloseSession(nullptr);
241     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
242 }
243 
244 /**
245  * @tc.name: CloseSession002
246  * @tc.desc: Test when sessionId is invalid then CloseSession returns SOFTBUS_TRANS_INVALID_SESSION_ID.
247  * @tc.type: FUNC
248  * @tc.require:
249  */
250 HWTEST_F(TransClientSessionServiceImplTest, CloseSession002, TestSize.Level0)
251 {
252     std::shared_ptr<SessionImpl> session = std::make_shared<SessionImpl>();
253     SessionServiceImpl sessionServiceImpl;
254     int32_t ret = sessionServiceImpl.CloseSession(session);
255     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
256     // testing::Mock::VerifyAndClearExpectations(&sessionServiceImplMock);
257 }
258 
259 /**
260  * @tc.name: CloseSession003
261  * @tc.desc: Test when sessionId is valid then CloseSession returns SOFTBUS_OK.
262  * @tc.type: FUNC
263  * @tc.require:
264  */
265 HWTEST_F(TransClientSessionServiceImplTest, CloseSession003, TestSize.Level0)
266 {
267     std::shared_ptr<SessionImpl> session = std::make_shared<SessionImpl>();
268     SessionServiceImpl sessionServiceImpl;
269     int32_t ret = sessionServiceImpl.CloseSession(session);
270     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
271 }
272 
273 /**
274  * @tc.name: GrantPermission001
275  * @tc.desc: Test when uid or pid is less than 0 then GrantPermission returns SOFTBUS_INVALID_PARAM.
276  * @tc.type: FUNC
277  * @tc.require:
278  */
279 HWTEST_F(TransClientSessionServiceImplTest, GrantPermission001, TestSize.Level0)
280 {
281     int32_t uid = -1;
282     int32_t pid = 1;
283     std::string busName = "busName";
284     SessionServiceImpl sessionServiceImpl;
285     int32_t result = sessionServiceImpl.GrantPermission(uid, pid, busName);
286     EXPECT_EQ(result, SOFTBUS_INVALID_PARAM);
287 }
288 
289 /**
290  * @tc.name: GrantPermission002
291  * @tc.desc: Test when busName is empty then GrantPermission returns SOFTBUS_INVALID_PARAM.
292  * @tc.type: FUNC
293  * @tc.require:
294  */
295 HWTEST_F(TransClientSessionServiceImplTest, GrantPermission002, TestSize.Level0)
296 {
297     int32_t uid = 1;
298     int32_t pid = 1;
299     std::string busName = "";
300     SessionServiceImpl sessionServiceImpl;
301     int32_t result = sessionServiceImpl.GrantPermission(uid, pid, busName);
302     EXPECT_EQ(result, SOFTBUS_INVALID_PARAM);
303 }
304 
305 /**
306  * @tc.name: RemovePermission001
307  * @tc.desc: Test when busName is empty then RemovePermission returns SOFTBUS_INVALID_PARAM.
308  * @tc.type: FUNC
309  * @tc.require:
310  */
311 HWTEST_F(TransClientSessionServiceImplTest, RemovePermission001, TestSize.Level0)
312 {
313     std::string busName = "";
314     SessionServiceImpl sessionServiceImpl;
315     int32_t result = sessionServiceImpl.RemovePermission(busName);
316     EXPECT_EQ(result, SOFTBUS_INVALID_PARAM);
317 }
318 } // SoftBus
319 } // Communication
320