• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 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 <securec.h>
17 
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_trans_def.h"
22 #include "softbus_json_utils.h"
23 #include "softbus_app_info.h"
24 #include "softbus_config_type.h"
25 #include "softbus_server_frame.h"
26 #include "softbus_adapter_mem.h"
27 #include "client_trans_message_service.h"
28 #include "client_trans_message_service.c"
29 #include "client_trans_session_manager.h"
30 #include "softbus_common.h"
31 #include "trans_log.h"
32 
33 
34 #define TRANS_TEST_SESSION_ID 10
35 #define TRANS_TEST_CHANNEL_ID 1000
36 #define TRANS_TEST_FILE_ENCRYPT 10
37 #define TRANS_TEST_ALGORITHM 1
38 #define TRANS_TEST_CRC 1
39 #define TRANS_TEST_AUTH_DATA "test auth message data"
40 #define TRANS_TEST_MAX_MSG_LEN (1 * 1024)
41 #define TRANS_TEST_MAX_BYTES_LEN (2 * 1024)
42 #define TRANS_TEST_BEYOND_MAX_MSG_LEN (6 * 1024)
43 #define TRANS_TEST_BEYOND_MAX_BYTES_LEN (6 * 1024 * 1024)
44 #define TRANS_TEST_SEND_LEN 123
45 #define TRANS_TEST_FILE_COUNT 2
46 
47 #define TRANS_TEST_INVALID_SEND_LEN (1024 * 1024)
48 
49 using namespace testing::ext;
50 
51 namespace OHOS {
52 
53 const char *g_pkgName = "dms";
54 const char *g_sessionName = "ohos.distributedschedule.dms.test";
55 const char *g_sessionKey = "www.huaweitest.com";
56 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
57 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
58 const char *g_groupId = "TEST_GROUP_ID";
59 static SessionAttribute g_sessionAttr = {
60     .dataType = TYPE_BYTES,
61 };
62 class TransClientMsgServiceTest : public testing::Test {
63 public:
TransClientMsgServiceTest()64     TransClientMsgServiceTest()
65     {}
~TransClientMsgServiceTest()66     ~TransClientMsgServiceTest()
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 TransClientMsgServiceTest::SetUpTestCase(void)
77 {
78     InitSoftBusServer();
79     int32_t ret = TransClientInit();
80     ASSERT_EQ(ret,  SOFTBUS_OK);
81 }
82 
TearDownTestCase(void)83 void TransClientMsgServiceTest::TearDownTestCase(void)
84 {
85 }
86 
OnSessionOpened(int sessionId,int result)87 static int OnSessionOpened(int sessionId, int result)
88 {
89     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
90     return SOFTBUS_OK;
91 }
92 
OnSessionClosed(int sessionId)93 static void OnSessionClosed(int sessionId)
94 {
95     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
96 }
97 
OnBytesReceived(int sessionId,const void * data,unsigned int len)98 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
99 {
100     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
101 }
102 
OnMessageReceived(int sessionId,const void * data,unsigned int len)103 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
104 {
105     TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
106 }
107 
OnStreamReceived(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)108 static void OnStreamReceived(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
109 {
110     TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
111 }
112 
OnQosEvent(int sessionId,int eventId,int tvCount,const QosTv * tvList)113 static void OnQosEvent(int sessionId, int eventId, int tvCount, const QosTv *tvList)
114 {
115     TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
116 }
117 
118 static ISessionListener g_sessionlistener = {
119     .OnSessionOpened = OnSessionOpened,
120     .OnSessionClosed = OnSessionClosed,
121     .OnBytesReceived = OnBytesReceived,
122     .OnMessageReceived = OnMessageReceived,
123     .OnStreamReceived = OnStreamReceived,
124     .OnQosEvent = OnQosEvent,
125 };
126 
TestGenerateCommParam(SessionParam * sessionParam)127 static void TestGenerateCommParam(SessionParam *sessionParam)
128 {
129     sessionParam->sessionName = g_sessionName;
130     sessionParam->peerSessionName = g_sessionName;
131     sessionParam->peerDeviceId = g_deviceId;
132     sessionParam->groupId = g_groupId;
133     sessionParam->attr = &g_sessionAttr;
134 }
135 
TestGenerateSession(const SessionParam * param)136 static SessionInfo *TestGenerateSession(const SessionParam *param)
137 {
138     SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
139     if (session == NULL) {
140         return NULL;
141     }
142 
143     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
144         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
145         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
146         SoftBusFree(session);
147         return NULL;
148     }
149 
150     session->sessionId = TRANS_TEST_SESSION_ID;
151     session->channelId = TRANS_TEST_CHANNEL_ID;
152     session->channelType = CHANNEL_TYPE_BUTT;
153     session->isServer = false;
154     session->isEnable = false;
155     session->routeType = ROUTE_TYPE_ALL;
156     session->info.flag = TYPE_BYTES;
157     session->isEncrypt = true;
158     session->algorithm = TRANS_TEST_ALGORITHM;
159     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
160     session->crc = TRANS_TEST_CRC;
161 
162     return session;
163 }
164 
AddSessionServerAndSession(const char * sessionName,int32_t channelType,int32_t businessType,bool isServer,bool isEnable)165 static int32_t AddSessionServerAndSession(const char *sessionName, int32_t channelType, int32_t businessType,
166                                           bool isServer, bool isEnable)
167 {
168     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
169     if (sessionParam == NULL) {
170         return SOFTBUS_ERR;
171     }
172 
173     TestGenerateCommParam(sessionParam);
174     sessionParam->sessionName = sessionName;
175     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener);
176     if (ret != SOFTBUS_OK) {
177         return SOFTBUS_ERR;
178     }
179 
180     SessionInfo *session = TestGenerateSession(sessionParam);
181     if (session == NULL) {
182         return SOFTBUS_ERR;
183     }
184 
185     session->channelType = (ChannelType)channelType;
186     session->businessType = (BusinessType)businessType;
187     session->isServer = isServer;
188     session->isEnable = isEnable;
189     ret = ClientAddNewSession(sessionName, session);
190     if (ret != SOFTBUS_OK) {
191         return SOFTBUS_ERR;
192     }
193 
194     int32_t sessionId = 0;
195     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId);
196     if (ret != SOFTBUS_OK) {
197         return SOFTBUS_ERR;
198     }
199     SoftBusFree(sessionParam);
200     return sessionId;
201 }
202 
DeleteSessionServerAndSession(const char * sessionName,int32_t sessionId)203 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
204 {
205     int32_t ret = ClientDeleteSession(sessionId);
206     EXPECT_EQ(ret, SOFTBUS_OK);
207     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
208     EXPECT_EQ(ret, SOFTBUS_OK);
209 }
210 
211 /**
212  * @tc.name: TransClientMsgServiceTest01
213  * @tc.desc: Transmission sdk message service check send length with different parameters.
214  * @tc.type: FUNC
215  * @tc.require:
216  */
217 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest01, TestSize.Level1)
218 {
219     int ret = CheckSendLen(CHANNEL_TYPE_BUTT, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
220     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
221     ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_INVALID_SEND_LEN, BUSINESS_TYPE_MESSAGE);
222     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
223     ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
224     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
225 }
226 
227 /**
228  * @tc.name: TransClientMsgServiceTest02
229  * @tc.desc: Transmission sdk message service send bytes with different parameters.
230  * @tc.type: FUNC
231  * @tc.require:
232  */
233 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest02, TestSize.Level1)
234 {
235     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, true);
236     ASSERT_GT(sessionId, 0);
237     int ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, 0);
238     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
239     DeleteSessionServerAndSession(g_sessionName, sessionId);
240 
241     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, true);
242     ASSERT_GT(sessionId, 0);
243     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
244     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
245     DeleteSessionServerAndSession(g_sessionName, sessionId);
246 
247     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, true);
248     ASSERT_GT(sessionId, 0);
249     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_BYTES_LEN);
250     EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
251     DeleteSessionServerAndSession(g_sessionName, sessionId);
252 
253     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, false);
254     ASSERT_GT(sessionId, 0);
255     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
256     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
257     DeleteSessionServerAndSession(g_sessionName, sessionId);
258 
259     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, true);
260     ASSERT_GT(sessionId, 0);
261     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
262     EXPECT_EQ(ret, SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND);
263     DeleteSessionServerAndSession(g_sessionName, sessionId);
264 }
265 
266 /**
267  * @tc.name: TransClientMsgServiceTest03
268  * @tc.desc: Transmission sdk message service send message with different parameters.
269  * @tc.type: FUNC
270  * @tc.require:
271  */
272 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest03, TestSize.Level1)
273 {
274     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
275     ASSERT_GT(sessionId, 0);
276     int ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, 0);
277     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
278     DeleteSessionServerAndSession(g_sessionName, sessionId);
279 
280     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
281     ASSERT_GT(sessionId, 0);
282     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
283     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
284     DeleteSessionServerAndSession(g_sessionName, sessionId);
285 
286     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, true);
287     ASSERT_GT(sessionId, 0);
288     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_MSG_LEN);
289     EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
290     DeleteSessionServerAndSession(g_sessionName, sessionId);
291 
292     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, false);
293     ASSERT_GT(sessionId, 0);
294     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
295     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
296     DeleteSessionServerAndSession(g_sessionName, sessionId);
297 
298     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, true);
299     ASSERT_GT(sessionId, 0);
300     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
301     EXPECT_EQ(ret, SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND);
302     DeleteSessionServerAndSession(g_sessionName, sessionId);
303 }
304 
305 /**
306  * @tc.name: TransClientMsgServiceTest04
307  * @tc.desc: Transmission sdk message service send stream with different parameters.
308  * @tc.type: FUNC
309  * @tc.require:
310  */
311 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest04, TestSize.Level1)
312 {
313     char dataBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
314     StreamData data = {
315         .buf = dataBuf,
316         .bufLen = TRANS_TEST_MAX_MSG_LEN
317     };
318     char extBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
319     StreamData ext = {
320         .buf = extBuf,
321         .bufLen = TRANS_TEST_MAX_MSG_LEN
322     };
323     StreamFrameInfo streamFrameInfo = {0};
324     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, true);
325     ASSERT_GT(sessionId, 0);
326     int ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
327     EXPECT_EQ(ret, SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL);
328     DeleteSessionServerAndSession(g_sessionName, sessionId);
329 
330     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
331     ASSERT_GT(sessionId, 0);
332     ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
333     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
334     DeleteSessionServerAndSession(g_sessionName, sessionId);
335 
336     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, false);
337     ASSERT_GT(sessionId, 0);
338     ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
339     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
340     DeleteSessionServerAndSession(g_sessionName, sessionId);
341 
342     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, true);
343     ASSERT_GT(sessionId, 0);
344     ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
345     EXPECT_NE(ret, SOFTBUS_OK);
346     DeleteSessionServerAndSession(g_sessionName, sessionId);
347 }
348 
349 /**
350  * @tc.name: TransClientMsgServiceTest05
351  * @tc.desc: Transmission sdk message service send file with different parameters.
352  * @tc.type: FUNC
353  * @tc.require:
354  */
355 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest05, TestSize.Level1)
356 {
357     const char *sFileList[TRANS_TEST_FILE_COUNT] = {
358         "/DATA/LOCAL/X",
359         "/DATA/LOCAL/Y"
360     };
361     const char *dFileList[TRANS_TEST_FILE_COUNT] = {
362         "/DATA/LOCAL/X",
363         "/DATA/LOCAL/Y"
364     };
365     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
366     ASSERT_GT(sessionId, 0);
367     int ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
368     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
369     DeleteSessionServerAndSession(g_sessionName, sessionId);
370     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, false);
371     ASSERT_GT(sessionId, 0);
372     ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
373     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
374     DeleteSessionServerAndSession(g_sessionName, sessionId);
375     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, true);
376     ASSERT_GT(sessionId, 0);
377     ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
378     EXPECT_EQ(ret, SOFTBUS_TRANS_CHANNEL_TYPE_INVALID);
379     DeleteSessionServerAndSession(g_sessionName, sessionId);
380 }
381 }