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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_session_json.c"
22 #include "auth_session_json_deps_mock.h"
23 #include "softbus_error_code.h"
24
25 namespace OHOS {
26 using namespace testing;
27 using namespace testing::ext;
28 constexpr int64_t TEST_AUTH_ID = 1;
29 constexpr int32_t KEY_VALUE_LEN = 13;
30 constexpr int32_t TEST_AUTH_PORT = 1;
31 constexpr int32_t TEST_SESSION_PORT = 2;
32 constexpr int32_t TEST_PROXY_PORT = 3;
33 constexpr uint8_t KEY_VALUE[SESSION_KEY_LENGTH] = "123456keytest";
34
35 class AuthSessionJsonMockTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase()43 void AuthSessionJsonMockTest::SetUpTestCase() {}
44
TearDownTestCase()45 void AuthSessionJsonMockTest::TearDownTestCase() {}
46
SetUp()47 void AuthSessionJsonMockTest::SetUp() {}
48
TearDown()49 void AuthSessionJsonMockTest::TearDown() {}
50
51 /*
52 * @tc.name: GET_ENHANCED_P2P_AUTH_KEY_TEST_001
53 * @tc.desc: GetEnhancedP2pAuthKey test
54 * @tc.type: FUNC
55 * @tc.require:
56 */
57 HWTEST_F(AuthSessionJsonMockTest, GET_ENHANCED_P2P_AUTH_KEY_TEST_001, TestSize.Level1)
58 {
59 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
60 char udidHash[SHA_256_HEX_HASH_LEN] = {0};
61 AuthSessionInfo info = {0};
62 AuthDeviceKeyInfo deviceKey = {0};
63 int32_t ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
64 EXPECT_EQ(ret, SOFTBUS_AUTH_NOT_FOUND);
65 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
66 EXPECT_EQ(ret, SOFTBUS_AUTH_NOT_FOUND);
67
68 AuthHandle authHandle = { .authId = TEST_AUTH_ID };
69 EXPECT_CALL(mocker, AuthGetLatestIdByUuid).WillRepeatedly(DoAll(SetArgPointee<3>(authHandle), Return()));
70 AuthManager auth = {0};
71 EXPECT_CALL(mocker, GetAuthManagerByAuthId).WillOnce(Return(nullptr)).WillRepeatedly(Return(&auth));
72 EXPECT_CALL(mocker, DelDupAuthManager).WillRepeatedly(Return());
73 SessionKey sessionKey = { .len = SESSION_KEY_LENGTH };
74 EXPECT_EQ(memcpy_s(sessionKey.value, SESSION_KEY_LENGTH, KEY_VALUE, KEY_VALUE_LEN), EOK);
75 EXPECT_CALL(mocker, GetLatestSessionKey).WillOnce(Return(SOFTBUS_INVALID_PARAM))
76 .WillRepeatedly(DoAll(SetArgPointee<3>(sessionKey), Return(SOFTBUS_OK)));
77
78 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
79 EXPECT_NE(ret, SOFTBUS_OK);
80 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
81 EXPECT_NE(ret, SOFTBUS_OK);
82 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
83 EXPECT_NE(ret, SOFTBUS_OK);
84 }
85
86 /*
87 * @tc.name: PACK_NORMALIZED_KEY_VALUE_TEST_001
88 * @tc.desc: PackNormalizedKeyValue test
89 * @tc.type: FUNC
90 * @tc.require:
91 */
92 HWTEST_F(AuthSessionJsonMockTest, PACK_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
93 {
94 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
95 uint32_t dataLen = 1;
96 uint8_t *data = reinterpret_cast<uint8_t *>(SoftBusMalloc(dataLen));
97 if (data == nullptr) {
98 return;
99 }
100 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM))
101 .WillRepeatedly(Return(SOFTBUS_OK));
102 EXPECT_CALL(mocker, LnnDecryptAesGcm).WillOnce(Return(SOFTBUS_INVALID_PARAM))
103 .WillOnce(DoAll(SetArgPointee<1>(nullptr), Return(SOFTBUS_OK)))
104 .WillOnce(DoAll(SetArgPointee<1>(data), SetArgPointee<2>(0), Return(SOFTBUS_OK)));
105 AuthSessionInfo info = {0};
106 AuthDeviceKeyInfo deviceKey = {0};
107 const char *fastAuth = "encryptedFastAuth";
108 ParseFastAuthValue(&info, fastAuth, &deviceKey);
109 ParseFastAuthValue(&info, fastAuth, &deviceKey);
110 ParseFastAuthValue(&info, fastAuth, &deviceKey);
111 ParseFastAuthValue(&info, fastAuth, &deviceKey);
112 EXPECT_CALL(mocker, LnnEncryptAesGcm).WillOnce(Return(SOFTBUS_INVALID_PARAM))
113 .WillOnce(DoAll(SetArgPointee<2>(nullptr), Return(SOFTBUS_OK)))
114 .WillOnce(DoAll(SetArgPointee<2>(data), SetArgPointee<3>(0), Return(SOFTBUS_OK)))
115 .WillRepeatedly(DoAll(SetArgPointee<2>(data), SetArgPointee<3>(dataLen), Return(SOFTBUS_OK)));
116 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString)
117 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
118 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(true));
119 JsonObj obj;
120 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
121 SessionKey sessionKey;
122 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
123 int32_t ret = PackNormalizedKeyValue(&obj, &sessionKey);
124 EXPECT_NE(ret, SOFTBUS_OK);
125 ret = PackNormalizedKeyValue(&obj, &sessionKey);
126 EXPECT_NE(ret, SOFTBUS_OK);
127 ret = PackNormalizedKeyValue(&obj, &sessionKey);
128 EXPECT_NE(ret, SOFTBUS_OK);
129 ret = PackNormalizedKeyValue(&obj, &sessionKey);
130 EXPECT_NE(ret, SOFTBUS_OK);
131 }
132
133 /*
134 * @tc.name: PARSE_NORMALIZED_KEY_VALUE_TEST_001
135 * @tc.desc: ParseNormalizedKeyValue test
136 * @tc.type: FUNC
137 * @tc.require:
138 */
139 HWTEST_F(AuthSessionJsonMockTest, PARSE_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
140 {
141 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
142 uint32_t dataLen = strlen("true");
143 uint8_t *data = reinterpret_cast<uint8_t *>(SoftBusMalloc(dataLen));
144 if (data == nullptr) {
145 return;
146 }
147 (void)memcpy_s(data, dataLen, "true", strlen("true"));
148 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM))
149 .WillRepeatedly(Return(SOFTBUS_OK));
150 EXPECT_CALL(mocker, LnnDecryptAesGcm).WillOnce(Return(SOFTBUS_INVALID_PARAM))
151 .WillOnce(DoAll(SetArgPointee<1>(nullptr), Return(SOFTBUS_OK)))
152 .WillOnce(DoAll(SetArgPointee<1>(data), SetArgPointee<2>(0), Return(SOFTBUS_OK)))
153 .WillRepeatedly(DoAll(SetArgPointee<1>(data), SetArgPointee<2>(dataLen), Return(SOFTBUS_OK)));
154 AuthSessionInfo info = {0};
155 SessionKey sessionKey;
156 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
157 const char *fastAuth = "encryptedFastAuth";
158 int32_t ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
159 EXPECT_NE(ret, SOFTBUS_OK);
160 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
161 EXPECT_NE(ret, SOFTBUS_OK);
162 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
163 EXPECT_NE(ret, SOFTBUS_OK);
164 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
165 EXPECT_NE(ret, SOFTBUS_OK);
166 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
167 EXPECT_EQ(ret, SOFTBUS_OK);
168 }
169
170 /*
171 * @tc.name: PARSE_NORMALIZE_DATA_TEST_001
172 * @tc.desc: ParseNormalizeData test
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(AuthSessionJsonMockTest, PARSE_NORMALIZE_DATA_TEST_001, TestSize.Level1)
177 {
178 int64_t authSeq = 1;
179 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
180 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
181 .WillRepeatedly(Return(SOFTBUS_OK));
182 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
183 .WillRepeatedly(Return(SOFTBUS_OK));
184 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
185 EXPECT_CALL(mocker, AuthUpdateCreateTime).WillRepeatedly(Return());
186 AuthSessionInfo info = {0};
187 AuthDeviceKeyInfo deviceKey = {0};
188 const char *key = "encnormalizedkeytest";
189 int32_t ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey, authSeq);
190 EXPECT_NE(ret, SOFTBUS_OK);
191 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey, authSeq);
192 EXPECT_NE(ret, SOFTBUS_OK);
193 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey, authSeq);
194 EXPECT_NE(ret, SOFTBUS_OK);
195 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey, authSeq);
196 EXPECT_NE(ret, SOFTBUS_OK);
197 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey, authSeq);
198 EXPECT_NE(ret, SOFTBUS_OK);
199 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey, authSeq);
200 EXPECT_NE(ret, SOFTBUS_OK);
201 }
202
203 /*
204 * @tc.name: VERIFY_SESSION_INFO_ID_TYPE_TEST_001
205 * @tc.desc: VerifySessionInfoIdType test
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(AuthSessionJsonMockTest, VERIFY_SESSION_INFO_ID_TYPE_TEST_001, TestSize.Level1)
210 {
211 AuthSessionInfo info = { .idType = EXCHANGE_NETWORKID, .connInfo.type = AUTH_LINK_TYPE_WIFI };
212 char *networkId = nullptr;
213 char *udid = nullptr;
214 JsonObj obj;
215 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
216 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
217 EXPECT_CALL(mocker, LnnGetLocalStrInfoByIfnameIdx).WillOnce(Return(SOFTBUS_INVALID_PARAM))
218 .WillRepeatedly(Return(SOFTBUS_OK));
219 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
220 .WillRepeatedly(Return(SOFTBUS_OK));
221 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString)
222 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
223 .WillRepeatedly(Return(SOFTBUS_OK));
224 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(false));
225 PackWifiSinglePassInfo(&obj, &info);
226 PackWifiSinglePassInfo(&obj, &info);
227 PackWifiSinglePassInfo(&obj, &info);
228 PackWifiSinglePassInfo(&obj, &info);
229 PackWifiSinglePassInfo(&obj, &info);
230 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false)).WillOnce(Return(false))
231 .WillRepeatedly(Return(true));
232 bool ret = VerifySessionInfoIdType(&info, &obj, networkId, udid);
233 EXPECT_NE(ret, true);
234 info.idType = EXCHANGE_UDID;
235 ret = VerifySessionInfoIdType(&info, &obj, networkId, udid);
236 EXPECT_NE(ret, true);
237 ret = VerifySessionInfoIdType(&info, &obj, networkId, udid);
238 EXPECT_EQ(ret, true);
239 }
240
241 /*
242 * @tc.name: PACK_DEVICE_JSON_INFO_TEST_001
243 * @tc.desc: PackDeviceJsonInfo test
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(AuthSessionJsonMockTest, PACK_DEVICE_JSON_INFO_TEST_001, TestSize.Level1)
248 {
249 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
250 EXPECT_CALL(mocker, IsSupportUDIDAbatement).WillRepeatedly(Return(true));
251 EXPECT_CALL(mocker, JSON_AddBoolToObject).WillRepeatedly(Return(false));
252 EXPECT_CALL(mocker, IsNeedUDIDAbatement).WillRepeatedly(Return(false));
253 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
254 .WillOnce(Return(false))
255 .WillRepeatedly(Return(true));
256 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false))
257 .WillRepeatedly(Return(true));
258 AuthSessionInfo info = {.connInfo.type = AUTH_LINK_TYPE_WIFI, .isConnectServer = false };
259 JsonObj obj;
260 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
261 PackUDIDAbatementFlag(&obj, &info);
262 int32_t ret = PackDeviceJsonInfo(&info, &obj);
263 EXPECT_NE(ret, SOFTBUS_OK);
264 info.isConnectServer = true;
265 ret = PackDeviceJsonInfo(&info, &obj);
266 EXPECT_NE(ret, SOFTBUS_OK);
267 ret = PackDeviceJsonInfo(&info, &obj);
268 EXPECT_NE(ret, SOFTBUS_OK);
269 ret = PackDeviceJsonInfo(&info, &obj);
270 EXPECT_EQ(ret, SOFTBUS_OK);
271 }
272
273 /*
274 * @tc.name: PACK_NORMALIZED_DATA_TEST_001
275 * @tc.desc: PackNormalizedData test
276 * @tc.type: FUNC
277 * @tc.require:
278 */
279 HWTEST_F(AuthSessionJsonMockTest, PACK_NORMALIZED_DATA_TEST_001, TestSize.Level1)
280 {
281 int64_t authSeq = 1;
282 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
283 EXPECT_CALL(mocker, IsSupportFeatureByCapaBit).WillRepeatedly(Return(false));
284 EXPECT_CALL(mocker, GetSessionKeyProfile).WillRepeatedly(Return(true));
285 EXPECT_CALL(mocker, JSON_AddBoolToObject).WillOnce(Return(false))
286 .WillRepeatedly(Return(true));
287 AuthSessionInfo info = { .isServer = true, .connInfo.type = AUTH_LINK_TYPE_WIFI };
288 NodeInfo nodeInfo;
289 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
290 JsonObj obj;
291 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
292 int32_t ret = PackNormalizedData(&info, &obj, &nodeInfo, authSeq);
293 EXPECT_NE(ret, SOFTBUS_OK);
294 EXPECT_CALL(mocker, JSON_GetStringFromObject).WillOnce(Return(false))
295 .WillRepeatedly(Return(false));
296 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
297 .WillRepeatedly(Return(SOFTBUS_OK));
298 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR, authSeq);
299 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR, authSeq);
300 EXPECT_EQ(info.normalizedKey, nullptr);
301 if (info.normalizedKey != nullptr) {
302 SoftBusFree(info.normalizedKey);
303 }
304 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR, authSeq);
305 EXPECT_EQ(info.normalizedKey, nullptr);
306 if (info.normalizedKey != nullptr) {
307 SoftBusFree(info.normalizedKey);
308 }
309 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR, authSeq);
310 EXPECT_EQ(info.normalizedKey, nullptr);
311 if (info.normalizedKey != nullptr) {
312 SoftBusFree(info.normalizedKey);
313 }
314 ret = PackNormalizedData(&info, &obj, &nodeInfo, authSeq);
315 EXPECT_EQ(ret, SOFTBUS_OK);
316 }
317
318 /*
319 * @tc.name: PACK_DEVICE_ID_JSON_TEST_001
320 * @tc.desc: PackDeviceIdJson test
321 * @tc.type: FUNC
322 * @tc.require:
323 */
324 HWTEST_F(AuthSessionJsonMockTest, PACK_DEVICE_ID_JSON_TEST_001, TestSize.Level1)
325 {
326 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
327 JsonObj obj;
328 int64_t authSeq = 1;
329 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
330 EXPECT_CALL(mocker, JSON_CreateObject).WillOnce(Return(nullptr))
331 .WillRepeatedly(Return(&obj));
332 EXPECT_CALL(mocker, JSON_Delete).WillRepeatedly(Return());
333 EXPECT_CALL(mocker, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
334 EXPECT_CALL(mocker, FindAuthPreLinkNodeById).WillRepeatedly(Return(SOFTBUS_OK));
335 AuthSessionInfo info = {0};
336 char *ret = PackDeviceIdJson(&info, authSeq);
337 EXPECT_EQ(ret, nullptr);
338 ret = PackDeviceIdJson(&info, authSeq);
339 EXPECT_EQ(ret, nullptr);
340 }
341
342 /*
343 * @tc.name: UNPACK_WIFI_SINGLE_PASS_INFO_TEST_001
344 * @tc.desc: UnpackWifiSinglePassInfo test
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(AuthSessionJsonMockTest, UNPACK_WIFI_SINGLE_PASS_INFO_TEST_001, TestSize.Level1)
349 {
350 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
351 EXPECT_CALL(mocker, JSON_GetStringFromObject).WillRepeatedly(Return(true));
352 EXPECT_CALL(mocker, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_INVALID_PARAM))
353 .WillRepeatedly(Return(SOFTBUS_OK));
354 JsonObj obj;
355 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
356 AuthSessionInfo info = { .connInfo.type = AUTH_LINK_TYPE_WIFI };
357 bool ret = UnpackWifiSinglePassInfo(&obj, &info);
358 EXPECT_EQ(ret, true);
359 ret = UnpackWifiSinglePassInfo(&obj, &info);
360 EXPECT_EQ(ret, true);
361 ret = UnpackWifiSinglePassInfo(&obj, &info);
362 EXPECT_EQ(ret, true);
363 ret = UnpackWifiSinglePassInfo(&obj, &info);
364 EXPECT_EQ(ret, true);
365 ret = UnpackWifiSinglePassInfo(&obj, &info);
366 EXPECT_EQ(ret, true);
367 }
368
369 /*
370 * @tc.name: VERIFY_EXCHANGE_ID_TYPE_AND_INFO_TEST_001
371 * @tc.desc: VerifyExchangeIdTypeAndInfo test
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(AuthSessionJsonMockTest, VERIFY_EXCHANGE_ID_TYPE_AND_INFO_TEST_001, TestSize.Level1)
376 {
377 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
378 EXPECT_CALL(mocker, GetPeerUdidByNetworkId).WillOnce(Return(SOFTBUS_INVALID_PARAM))
379 .WillRepeatedly(Return(SOFTBUS_OK));
380 EXPECT_CALL(mocker, GetIsExchangeUdidByNetworkId).WillOnce(Return(SOFTBUS_OK))
381 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
382 AuthSessionInfo info;
383 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
384 const char *anonyUdid = "0123456789ABC";
385 char testUdid[UDID_BUF_LEN] = "0123456789ABC";
386 EXPECT_EQ(strcpy_s(info.udid, UDID_BUF_LEN, testUdid), EOK);
387 int32_t ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_UDID, const_cast<char *>(anonyUdid));
388 EXPECT_EQ(ret, SOFTBUS_OK);
389 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
390 EXPECT_EQ(ret, SOFTBUS_OK);
391 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
392 EXPECT_EQ(ret, SOFTBUS_OK);
393 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
394 EXPECT_EQ(ret, SOFTBUS_OK);
395 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
396 EXPECT_EQ(ret, SOFTBUS_OK);
397 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
398 EXPECT_EQ(ret, SOFTBUS_OK);
399 }
400
401 /*
402 * @tc.name: SET_EXCHANGE_ID_TYPE_AND_VALUE_TEST_001
403 * @tc.desc: SetExchangeIdTypeAndValue test
404 * @tc.type: FUNC
405 * @tc.require:
406 */
407 HWTEST_F(AuthSessionJsonMockTest, SET_EXCHANGE_ID_TYPE_AND_VALUE_TEST_001, TestSize.Level1)
408 {
409 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
410 EXPECT_CALL(mocker, JSON_GetInt32FromOject).WillRepeatedly(Return(false));
411 JsonObj obj;
412 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
413 AuthSessionInfo info;
414 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
415 int32_t ret = SetExchangeIdTypeAndValue(&obj, &info);
416 EXPECT_EQ(ret, SOFTBUS_OK);
417 EXPECT_CALL(mocker, AuthMetaGetConnIdByInfo).WillRepeatedly(Return(SOFTBUS_OK));
418 EXPECT_CALL(mocker, LnnDumpRemotePtk).WillRepeatedly(Return());
419 EXPECT_CALL(mocker, SoftBusBase64Encode).WillOnce(Return(SOFTBUS_INVALID_PARAM))
420 .WillRepeatedly(Return(SOFTBUS_OK));
421 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
422 .WillOnce(Return(true))
423 .WillOnce(Return(false))
424 .WillRepeatedly(Return(true));
425 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false))
426 .WillRepeatedly(Return(true));
427 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
428 .WillRepeatedly(Return(SOFTBUS_OK));
429 AuthConnInfo connInfo;
430 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
431 NodeInfo nodeInfo;
432 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
433 const char *remoteUuid = "remoteUuidTest";
434 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, true);
435 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, nullptr, false);
436 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
437 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
438 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
439 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
440 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
441 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
442 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
443 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
444 ret = SetExchangeIdTypeAndValue(&obj, nullptr);
445 EXPECT_NE(ret, SOFTBUS_OK);
446 ret = SetExchangeIdTypeAndValue(nullptr, &info);
447 EXPECT_NE(ret, SOFTBUS_OK);
448 }
449
450 /*
451 * @tc.name: PACK_CIPHER_RPA_INFO_TEST_001
452 * @tc.desc: PackCipherRpaInfo test
453 * @tc.type: FUNC
454 * @tc.require:
455 */
456 HWTEST_F(AuthSessionJsonMockTest, PACK_CIPHER_RPA_INFO_TEST_001, TestSize.Level1)
457 {
458 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
459 JsonObj json;
460 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
461 NodeInfo info;
462 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
463 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM));
464 int32_t ret = PackCipherRpaInfo(&json, &info);
465 EXPECT_NE(ret, SOFTBUS_OK);
466 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK))
467 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
468 ret = PackCipherRpaInfo(&json, &info);
469 EXPECT_NE(ret, SOFTBUS_OK);
470 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK))
471 .WillOnce(Return(SOFTBUS_OK))
472 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
473 ret = PackCipherRpaInfo(&json, &info);
474 EXPECT_NE(ret, SOFTBUS_OK);
475 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK))
476 .WillOnce(Return(SOFTBUS_OK))
477 .WillOnce(Return(SOFTBUS_OK))
478 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
479 ret = PackCipherRpaInfo(&json, &info);
480 EXPECT_NE(ret, SOFTBUS_OK);
481 EXPECT_CALL(mocker, ConvertBytesToHexString).WillRepeatedly(Return(SOFTBUS_OK));
482 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(true));
483 ret = PackCipherRpaInfo(&json, &info);
484 EXPECT_EQ(ret, SOFTBUS_OK);
485 ret = PackCipherRpaInfo(&json, &info);
486 EXPECT_EQ(ret, SOFTBUS_OK);
487 }
488
489 /*
490 * @tc.name: PACK_COMMON_EX_TEST_001
491 * @tc.desc: PackCommonEx test
492 * @tc.type: FUNC
493 * @tc.require:
494 */
495 HWTEST_F(AuthSessionJsonMockTest, PACK_COMMON_EX_TEST_001, TestSize.Level1)
496 {
497 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
498 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
499 .WillRepeatedly(Return(true));
500 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
501 EXPECT_CALL(mocker, JSON_AddInt16ToObject).WillRepeatedly(Return(true));
502 EXPECT_CALL(mocker, JSON_AddBoolToObject).WillRepeatedly(Return(true));
503 EXPECT_CALL(mocker, JSON_AddInt64ToObject).WillRepeatedly(Return(true));
504 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
505 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
506 EXPECT_CALL(mocker, LnnGetSupportedProtocols).WillRepeatedly(Return(0));
507 JsonObj json;
508 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
509 NodeInfo info;
510 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
511 int32_t ret = PackCommonEx(&json, &info);
512 EXPECT_NE(ret, SOFTBUS_OK);
513 EXPECT_CALL(mocker, JSON_GetStringFromObject).WillRepeatedly(Return(true));
514 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM));
515 UnpackCipherRpaInfo(&json, &info);
516 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_OK))
517 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
518 UnpackCipherRpaInfo(&json, &info);
519 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_OK))
520 .WillOnce(Return(SOFTBUS_OK))
521 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
522 UnpackCipherRpaInfo(&json, &info);
523 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillRepeatedly(Return(SOFTBUS_OK));
524 UnpackCipherRpaInfo(&json, &info);
525 const char *btMac = "00:11:22:33:44:55";
526 EXPECT_CALL(mocker, LnnGetBtMac).WillRepeatedly(Return(btMac));
527 EXPECT_CALL(mocker, StringToUpperCase).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
528 ret = PackCommonEx(&json, &info);
529 EXPECT_EQ(ret, SOFTBUS_OK);
530 }
531
532 /*
533 * @tc.name: PACK_COMMON_TEST_001
534 * @tc.desc: PackCommon test
535 * @tc.type: FUNC
536 * @tc.require:
537 */
538 HWTEST_F(AuthSessionJsonMockTest, PACK_COMMON_TEST_001, TestSize.Level1)
539 {
540 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
541 JsonObj json;
542 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
543 NodeInfo info;
544 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
545 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false));
546 int32_t ret = PackCommon(&json, &info, SOFTBUS_NEW_V1, true);
547 EXPECT_NE(ret, SOFTBUS_OK);
548 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(true));
549 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false));
550 ret = PackCommon(&json, &info, SOFTBUS_NEW_V1, true);
551 EXPECT_NE(ret, SOFTBUS_OK);
552 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(true))
553 .WillOnce(Return(false));
554 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(true));
555 ret = PackCommon(&json, &info, SOFTBUS_NEW_V1, true);
556 EXPECT_NE(ret, SOFTBUS_OK);
557 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false));
558 ret = PackCommon(&json, &info, SOFTBUS_OLD_V2, true);
559 EXPECT_NE(ret, SOFTBUS_OK);
560 }
561
562 /*
563 * @tc.name: PACK_BT_TEST_001
564 * @tc.desc: PackBt test
565 * @tc.type: FUNC
566 * @tc.require:
567 */
568 HWTEST_F(AuthSessionJsonMockTest, PACK_BT_TEST_001, TestSize.Level1)
569 {
570 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
571 JsonObj json;
572 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
573 NodeInfo info;
574 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
575 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false));
576 EXPECT_CALL(mocker, LnnGetNetworkIdByUuid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
577 .WillRepeatedly(Return(SOFTBUS_OK));
578 const char *remoteUuid = "remoteUuidTest";
579 AddDiscoveryType(&json, nullptr);
580 AddDiscoveryType(&json, remoteUuid);
581 EXPECT_CALL(mocker, LnnGetRemoteNumInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
582 AddDiscoveryType(&json, remoteUuid);
583 int32_t ret = PackBt(&json, &info, SOFTBUS_NEW_V1, true, remoteUuid);
584 EXPECT_NE(ret, SOFTBUS_OK);
585 }
586
587 /*
588 * @tc.name: PACK_WIFI_TEST_001
589 * @tc.desc: PackWiFi test
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(AuthSessionJsonMockTest, PACK_WIFI_TEST_001, TestSize.Level1)
594 {
595 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
596 JsonObj json;
597 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
598 NodeInfo info;
599 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
600 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(false));
601 EXPECT_CALL(mocker, LnnGetAuthPort).WillRepeatedly(Return(TEST_AUTH_PORT));
602 EXPECT_CALL(mocker, LnnGetSessionPort).WillRepeatedly(Return(TEST_SESSION_PORT));
603 EXPECT_CALL(mocker, LnnGetProxyPort).WillRepeatedly(Return(TEST_PROXY_PORT));
604 int32_t ret = PackWiFi(&json, &info, SOFTBUS_NEW_V1, false, WLAN_IF);
605 EXPECT_NE(ret, SOFTBUS_OK);
606 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
607 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(true));
608 EXPECT_CALL(mocker, SoftBusBase64Encode).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
609 ret = PackWiFi(&json, &info, SOFTBUS_NEW_V1, false, WLAN_IF);
610 EXPECT_NE(ret, SOFTBUS_OK);
611 }
612
613 /*
614 * @tc.name: PACK_CERTIFICATEINFO_TEST_001
615 * @tc.desc: PackCertificateInfo test
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(AuthSessionJsonMockTest, PACK_CERTIFICATEINFO_TEST_001, TestSize.Level1)
620 {
621 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
622 JsonObj json;
623 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
624 AuthSessionInfo info;
625 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
626 info.isNeedPackCert = false;
627 int32_t ret = PackCertificateInfo(&json, nullptr);
628 EXPECT_EQ(ret, SOFTBUS_OK);
629 ret = PackCertificateInfo(&json, &info);
630 EXPECT_EQ(ret, SOFTBUS_OK);
631 ret = PackCertificateInfo(&json, &info);
632 EXPECT_EQ(ret, SOFTBUS_OK);
633 info.isNeedPackCert = true;
634 ret = PackCertificateInfo(&json, &info);
635 EXPECT_EQ(ret, SOFTBUS_OK);
636 EXPECT_CALL(mocker, JSON_AddBytesToObject).WillRepeatedly(Return(false));
637 EXPECT_CALL(mocker, FreeSoftbusChain).WillRepeatedly(Return());
638 ret = PackCertificateInfo(&json, &info);
639 EXPECT_EQ(ret, SOFTBUS_OK);
640 EXPECT_CALL(mocker, JSON_AddBytesToObject).WillRepeatedly(Return(true));
641 EXPECT_EQ(ret, SOFTBUS_OK);
642 }
643
644 /*
645 * @tc.name: UNPACK_CERTIFICATEINFO_TEST_001
646 * @tc.desc: UnpackCertificateInfo test
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(AuthSessionJsonMockTest, UNPACK_CERTIFICATEINFO_TEST_001, TestSize.Level1)
651 {
652 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
653 JsonObj json;
654 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
655 AuthSessionInfo info;
656 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
657 NodeInfo nodeInfo;
658 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
659 int32_t ret = UnpackCertificateInfo(nullptr, &nodeInfo, &info);
660 EXPECT_EQ(ret, SOFTBUS_OK);
661 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
662 EXPECT_EQ(ret, SOFTBUS_OK);
663 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
664 EXPECT_EQ(ret, SOFTBUS_OK);
665 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
666 EXPECT_EQ(ret, SOFTBUS_OK);
667 EXPECT_CALL(mocker, JSON_GetBytesFromObject).WillRepeatedly(Return(false));
668 EXPECT_CALL(mocker, FreeSoftbusChain).WillRepeatedly(Return());
669 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
670 EXPECT_EQ(ret, SOFTBUS_OK);
671 EXPECT_CALL(mocker, JSON_GetBytesFromObject).WillRepeatedly(Return(true));
672 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
673 EXPECT_EQ(ret, SOFTBUS_OK);
674 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
675 EXPECT_EQ(ret, SOFTBUS_OK);
676 }
677
678 /*
679 * @tc.name: PACK_USER_ID_CHECK_SUM_TEST_001
680 * @tc.desc: PackUserIdCheckSum test
681 * @tc.type: FUNC
682 * @tc.require:
683 */
684 HWTEST_F(AuthSessionJsonMockTest, PACK_USER_ID_CHECK_SUM_TEST_001, TestSize.Level1)
685 {
686 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
687 JsonObj json;
688 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
689 NodeInfo nodeInfo;
690 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
691 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
692 .WillRepeatedly(Return(SOFTBUS_OK));
693 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
694 .WillRepeatedly(Return(true));
695 int32_t ret = PackUserIdCheckSum(&json, &nodeInfo);
696 EXPECT_NE(ret, SOFTBUS_OK);
697 ret = PackUserIdCheckSum(&json, &nodeInfo);
698 EXPECT_NE(ret, SOFTBUS_OK);
699 ret = PackUserIdCheckSum(&json, &nodeInfo);
700 EXPECT_EQ(ret, SOFTBUS_OK);
701 }
702
703 /*
704 * @tc.name: PACK_DEVICE_INFO_MESSAGE_TEST_001
705 * @tc.desc: PackDeviceInfoMessage test
706 * @tc.type: FUNC
707 * @tc.require:
708 */
709 HWTEST_F(AuthSessionJsonMockTest, PACK_DEVICE_INFO_MESSAGE_TEST_001, TestSize.Level1)
710 {
711 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
712 AuthConnInfo connInfo;
713 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
714 AuthSessionInfo info;
715 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
716 NodeInfo nodeInfo;
717 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
718 EXPECT_CALL(mocker, LnnGetLocalNodeInfoSafe).WillOnce(Return(SOFTBUS_INVALID_PARAM))
719 .WillRepeatedly(Return(SOFTBUS_OK));
720 const char *brMacTempNull = "";
721 const char *brMacTempInvalid = "00:00:00:00:00:00";
722 const char *brMacTemp = "00:11:22:33:44:55";
723 EXPECT_CALL(mocker, LnnGetBtMac).WillOnce(Return(brMacTempNull)).WillOnce(Return(brMacTempInvalid))
724 .WillRepeatedly(Return(brMacTemp));
725 EXPECT_CALL(mocker, SoftBusGetBtState).WillOnce(Return(BLE_DISABLE))
726 .WillRepeatedly(Return(BLE_ENABLE));
727 EXPECT_CALL(mocker, SoftBusGetBtMacAddr).WillOnce(Return(SOFTBUS_INVALID_PARAM))
728 .WillRepeatedly(Return(SOFTBUS_OK));
729 EXPECT_CALL(mocker, LnnGetLocalNodeInfo).WillRepeatedly(Return(nullptr));
730 const char *remoteUuid = "remoteUuidTest";
731 char *ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
732 EXPECT_EQ(ret, nullptr);
733 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
734 EXPECT_EQ(ret, nullptr);
735 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
736 EXPECT_EQ(ret, nullptr);
737 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
738 EXPECT_EQ(ret, nullptr);
739 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
740 EXPECT_EQ(ret, nullptr);
741 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
742 EXPECT_EQ(ret, nullptr);
743 }
744 } // namespace OHOS