1 /*
2 * Copyright (c) 2025 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 <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include <sys/time.h>
21
22 #include "auth_connection.h"
23 #include "auth_connection.c"
24 #include "auth_device.c"
25 #include "auth_interface.h"
26 #include "auth_interface_mock.h"
27 #include "auth_interface.c"
28 #include "auth_lane.c"
29 #include "auth_log.h"
30 #include "auth_manager.h"
31 #include "auth_session_fsm.h"
32 #include "auth_session_fsm.c"
33 #include "auth_session_key.h"
34 #include "auth_session_key.c"
35 #include "softbus_error_code.h"
36 #include "softbus_adapter_json.h"
37 #include "softbus_socket.h"
38 #include "lnn_ctrl_lane.h"
39 #include "lnn_lane_score.h"
40 #include "lnn_lane_interface.h"
41
42 namespace OHOS {
43 using namespace testing::ext;
44 using namespace testing;
45 constexpr char NODE_BR_MAC[] = "12345TTU";
46 constexpr char NODE_BLE_MAC[] = "23456TTU";
47 constexpr char NODE_IP[] = "10.146.181.134";
48 constexpr uint32_t TEST_DATA_LEN = 30;
49 constexpr uint32_t AUTH_DEFAULT_VALUE = 0;
50 constexpr int32_t INDEX = 1;
51 class AuthOtherMockTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase()59 void AuthOtherMockTest::SetUpTestCase()
60 {
61 }
62
TearDownTestCase()63 void AuthOtherMockTest::TearDownTestCase()
64 {
65 }
66
SetUp()67 void AuthOtherMockTest::SetUp()
68 {
69 }
70
TearDown()71 void AuthOtherMockTest::TearDown()
72 {
73 }
74
75 /*
76 * @tc.name: AUTH_INIT_TEST_001
77 * @tc.desc: AuthInit test success
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(AuthOtherMockTest, AUTH_INIT_TEST_001, TestSize.Level1)
82 {
83 AuthOtherInterfaceMock authMock;
84 EXPECT_CALL(authMock, AuthDeviceInit).WillOnce(Return(SOFTBUS_INVALID_PARAM))
85 .WillRepeatedly(Return(SOFTBUS_OK));
86 EXPECT_CALL(authMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
87 EXPECT_CALL(authMock, RegHichainSaStatusListener).WillRepeatedly(Return(SOFTBUS_OK));
88 EXPECT_CALL(authMock, CustomizedSecurityProtocolInit).WillRepeatedly(Return(SOFTBUS_OK));
89 EXPECT_CALL(authMock, AuthMetaInit).WillRepeatedly(Return(SOFTBUS_OK));
90 int32_t ret = AuthInit();
91 EXPECT_EQ(ret, SOFTBUS_AUTH_INIT_FAIL);
92 ret = AuthInit();
93 EXPECT_EQ(ret, SOFTBUS_OK);
94 EXPECT_NO_FATAL_FAILURE(AuthDeinit());
95 }
96
97 /*
98 * @tc.name: AUTH_INIT_TEST_002
99 * @tc.desc: AuthInit test failed
100 * @tc.type: FUNC
101 * @tc.require:
102 */
103 HWTEST_F(AuthOtherMockTest, AUTH_INIT_TEST_002, TestSize.Level1)
104 {
105 AuthOtherInterfaceMock authMock;
106 EXPECT_CALL(authMock, AuthDeviceInit).WillRepeatedly(Return(SOFTBUS_OK));
107 EXPECT_CALL(authMock, RegHichainSaStatusListener).WillOnce(Return(SOFTBUS_AUTH_GET_SA_MANAGER_FAIL))
108 .WillRepeatedly(Return(SOFTBUS_OK));
109 EXPECT_CALL(authMock, CustomizedSecurityProtocolInit).WillRepeatedly(Return(SOFTBUS_CREATE_LIST_ERR));
110 int32_t ret = AuthInit();
111 EXPECT_EQ(ret, SOFTBUS_AUTH_HICHAIN_SA_PROC_ERR);
112 ret = AuthInit();
113 EXPECT_EQ(ret, SOFTBUS_CREATE_LIST_ERR);
114 EXPECT_NO_FATAL_FAILURE(AuthDeinit());
115 }
116
117 /*
118 * @tc.name: AUTH_CHECK_META_EXIST_TEST_001
119 * @tc.desc: AuthCheckMetaExist test success
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(AuthOtherMockTest, AUTH_CHECK_META_EXIST_TEST_001, TestSize.Level1)
124 {
125 AuthConnInfo connInfo;
126 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
127 ASSERT_EQ(strcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, NODE_BR_MAC), EOK);
128 ASSERT_EQ(strcpy_s(connInfo.info.bleInfo.bleMac, BT_MAC_LEN, NODE_BLE_MAC), EOK);
129 ASSERT_EQ(strcpy_s(connInfo.info.ipInfo.ip, IP_STR_MAX_LEN, NODE_IP), EOK);
130 bool isExist = false;
131 int32_t ret = AuthCheckMetaExist(&connInfo, &isExist);
132 EXPECT_EQ(ret, SOFTBUS_OK);
133 }
134
135 /*
136 * @tc.name: AUTH_CHECK_META_EXIST_TEST_002
137 * @tc.desc: AuthCheckMetaExist test failed
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 HWTEST_F(AuthOtherMockTest, AUTH_CHECK_META_EXIST_TEST_002, TestSize.Level1)
142 {
143 bool isExist = false;
144 int32_t ret = AuthCheckMetaExist(nullptr, &isExist);
145 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
146 AuthConnInfo connInfo;
147 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
148 ret = AuthCheckMetaExist(&connInfo, nullptr);
149 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
150 }
151
152 /*
153 * @tc.name: AUTH_HAS_TRUSTED_RELATION_TEST_001
154 * @tc.desc: AuthHasTrustedRelation test success
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(AuthOtherMockTest, AUTH_HAS_TRUSTED_RELATION_TEST_001, TestSize.Level1)
159 {
160 AuthOtherInterfaceMock authMock;
161 EXPECT_CALL(authMock, LnnGetTrustedDevInfoFromDb).WillRepeatedly(Return(SOFTBUS_OK));
162 TrustedReturnType ret = AuthHasTrustedRelation();
163 EXPECT_EQ(ret, TRUSTED_RELATION_NO);
164 }
165
166 /*
167 * @tc.name: AUTH_HAS_TRUSTED_RELATION_TEST_002
168 * @tc.desc: AuthHasTrustedRelation test failed
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 HWTEST_F(AuthOtherMockTest, AUTH_HAS_TRUSTED_RELATION_TEST_002, TestSize.Level1)
173 {
174 AuthOtherInterfaceMock authMock;
175 EXPECT_CALL(authMock, LnnGetTrustedDevInfoFromDb).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
176 TrustedReturnType ret = AuthHasTrustedRelation();
177 EXPECT_EQ(ret, TRUSTED_RELATION_IGNORE);
178 }
179
180 /*
181 * @tc.name: AUTH_HAS_SAME_ACCOUNT_GROUP_TEST_001
182 * @tc.desc: AuthHasSameAccountGroup test
183 * @tc.type: FUNC
184 * @tc.require:
185 */
186 HWTEST_F(AuthOtherMockTest, AUTH_HAS_SAME_ACCOUNT_GROUP_TEST_001, TestSize.Level1)
187 {
188 AuthOtherInterfaceMock authMock;
189 EXPECT_CALL(authMock, IsSameAccountGroupDevice).WillOnce(Return(true)).WillRepeatedly(Return(false));
190 bool ret = AuthHasSameAccountGroup();
191 EXPECT_TRUE(ret);
192 ret = AuthHasSameAccountGroup();
193 EXPECT_FALSE(ret);
194 }
195
196 /*
197 * @tc.name: IS_SAME_ACCOUNT_DEVICE_TEST_001
198 * @tc.desc: IsSameAccountDevice test failed
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(AuthOtherMockTest, IS_SAME_ACCOUNT_DEVICE_TEST_001, TestSize.Level1)
203 {
204 AuthOtherInterfaceMock authMock;
205 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
206
207 DeviceInfo device = {
208 .devId = "testId",
209 .accountHash = "accounthashtest",
210 };
211 EXPECT_FALSE(IsSameAccountDevice(&device));
212 }
213
214 /*
215 * @tc.name: IS_SAME_ACCOUNT_DEVICE_TEST_002
216 * @tc.desc: IsSameAccountDevice test failed
217 * @tc.type: FUNC
218 * @tc.require:
219 */
220 HWTEST_F(AuthOtherMockTest, IS_SAME_ACCOUNT_DEVICE_TEST_002, TestSize.Level1)
221 {
222 AuthOtherInterfaceMock authMock;
223 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
224 DeviceInfo device = {
225 .devId = "testId",
226 .accountHash = "accounthashtest",
227 };
228 EXPECT_FALSE(IsSameAccountDevice(&device));
229 }
230
231 /*
232 * @tc.name: AUTH_IS_POTENTIAL_TRUSTED_TEST_001
233 * @tc.desc: AuthIsPotentialTrusted test success
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(AuthOtherMockTest, AUTH_IS_POTENTIAL_TRUSTED_TEST_001, TestSize.Level1)
238 {
239 AuthOtherInterfaceMock authMock;
240 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
241 EXPECT_CALL(authMock, LnnIsDefaultOhosAccount).WillRepeatedly(Return(true));
242 EXPECT_CALL(authMock, IsPotentialTrustedDevice).WillRepeatedly(Return(true));
243 DeviceInfo device = {
244 .devId = "testId",
245 .accountHash = "accounthashtest",
246 };
247 EXPECT_TRUE(AuthIsPotentialTrusted(&device));
248 }
249
250 /*
251 * @tc.name: AUTH_IS_POTENTIAL_TRUSTED_TEST_002
252 * @tc.desc: AuthIsPotentialTrusted test failed
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(AuthOtherMockTest, AUTH_IS_POTENTIAL_TRUSTED_TEST_002, TestSize.Level1)
257 {
258 AuthOtherInterfaceMock authMock;
259 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
260 DeviceInfo device = {
261 .devId = "testId",
262 .accountHash = "accounthashtest",
263 };
264 EXPECT_FALSE(AuthIsPotentialTrusted(&device));
265 }
266
267 /*
268 * @tc.name: AUTH_GET_GROUP_TEST_001
269 * @tc.desc: AuthGetGroupType test failed
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(AuthOtherMockTest, AUTH_GET_GROUP_TEST_001, TestSize.Level1)
274 {
275 const char *udid = "testudid";
276 const char *uuid = "testuuid";
277 uint32_t type = AuthGetGroupType(nullptr, uuid);
278 EXPECT_EQ(type, AUTH_DEFAULT_VALUE);
279 type = AuthGetGroupType(udid, nullptr);
280 EXPECT_EQ(type, AUTH_DEFAULT_VALUE);
281 }
282
283 /*
284 * @tc.name: AUTH_GET_META_TYPE_TEST_001
285 * @tc.desc: AuthGetMetaType test
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(AuthOtherMockTest, AUTH_GET_META_TYPE_TEST_001, TestSize.Level1)
290 {
291 int64_t authId = 0;
292 const char *udid = "000";
293 const char *uuid = "000";
294 const char *ip = "192.168.12.1";
295 AuthSessionInfo info;
296 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
297 ASSERT_EQ(strcpy_s(info.udid, UDID_BUF_LEN, udid), EOK);
298 ASSERT_EQ(strcpy_s(info.uuid, UUID_BUF_LEN, uuid), EOK);
299 ASSERT_EQ(strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip), EOK);
300 info.connId = 0;
301 info.isServer = false;
302 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
303 AuthManager *auth = NewAuthManager(authId, &info);
304 ASSERT_NE(auth, nullptr);
305
306 AuthOtherInterfaceMock authMock;
307 EXPECT_CALL(authMock, GetAuthManagerByAuthId).WillRepeatedly(Return(nullptr));
308
309 bool isMetaAuth = false;
310 int32_t ret = AuthGetMetaType(authId, &isMetaAuth);
311 EXPECT_EQ(ret, SOFTBUS_OK);
312 EXPECT_TRUE(isMetaAuth);
313
314 DelAuthManager(auth, info.connInfo.type);
315 }
316
317 /*
318 * @tc.name: AUTH_RESTORE_AUTH_MANAGER_TEST_001
319 * @tc.desc: AuthRestoreAuthManager test failed
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(AuthOtherMockTest, AUTH_RESTORE_AUTH_MANAGER_TEST_001, TestSize.Level1)
324 {
325 AuthOtherInterfaceMock authMock;
326 EXPECT_CALL(authMock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_OK));
327 EXPECT_CALL(authMock, IsCloudSyncEnabled).WillRepeatedly(Return(true));
328 EXPECT_CALL(authMock, IsFeatureSupport).WillRepeatedly(Return(true));
329 EXPECT_CALL(authMock, SoftBusGenerateStrHash)
330 .WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
331 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
332
333 AuthConnInfo connInfo = {
334 .type = AUTH_LINK_TYPE_BLE,
335 };
336 const char *udidHash = "uuidHash";
337 uint32_t requestId = 1;
338 int64_t authId = 0;
339 NodeInfo nodeInfo;
340 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
341 int32_t ret = AuthRestoreAuthManager(udidHash, &connInfo, requestId, &nodeInfo, &authId);
342 EXPECT_EQ(ret, SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR);
343 ret = AuthRestoreAuthManager(udidHash, &connInfo, requestId, &nodeInfo, &authId);
344 EXPECT_EQ(ret, SOFTBUS_AUTH_SESSION_KEY_PROC_ERR);
345 }
346
347 /*
348 * @tc.name: AUTH_RESTORE_AUTH_MANAGER_TEST_002
349 * @tc.desc: AuthRestoreAuthManager test failed
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(AuthOtherMockTest, AUTH_RESTORE_AUTH_MANAGER_TEST_002, TestSize.Level1)
354 {
355 AuthOtherInterfaceMock authMock;
356 EXPECT_CALL(authMock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_OK));
357 EXPECT_CALL(authMock, IsCloudSyncEnabled).WillRepeatedly(Return(true));
358 EXPECT_CALL(authMock, IsFeatureSupport).WillRepeatedly(Return(true));
359 EXPECT_CALL(authMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
360 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
361
362 AuthConnInfo connInfo = {
363 .type = AUTH_LINK_TYPE_BLE,
364 };
365 const char *udidHash = "uuidHash";
366 uint32_t requestId = 1;
367 int64_t authId = 0;
368 NodeInfo nodeInfo;
369 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
370 int32_t ret = AuthRestoreAuthManager(udidHash, &connInfo, requestId, &nodeInfo, &authId);
371 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
372 }
373
374 /*
375 * @tc.name: AUTH_RESTORE_AUTH_MANAGER_TEST_003
376 * @tc.desc: AuthRestoreAuthManager mock AuthFindDeviceKey test
377 * @tc.type: FUNC
378 * @tc.require:
379 */
380 HWTEST_F(AuthOtherMockTest, AUTH_RESTORE_AUTH_MANAGER_TEST_003, TestSize.Level1)
381 {
382 AuthOtherInterfaceMock authMock;
383 EXPECT_CALL(authMock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
384 EXPECT_CALL(authMock, AuthFindDeviceKey).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
385 EXPECT_CALL(authMock, IsCloudSyncEnabled).WillRepeatedly(Return(true));
386 EXPECT_CALL(authMock, IsFeatureSupport).WillRepeatedly(Return(true));
387 EXPECT_CALL(authMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
388 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
389
390 AuthConnInfo connInfo = {
391 .type = AUTH_LINK_TYPE_BLE,
392 };
393 const char *udidHash = "uuidHash";
394 uint32_t requestId = 1;
395 int64_t authId = 0;
396 NodeInfo nodeInfo;
397 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
398 int32_t ret = AuthRestoreAuthManager(udidHash, &connInfo, requestId, &nodeInfo, &authId);
399 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
400 }
401
402 /*
403 * @tc.name: AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001
404 * @tc.desc: AuthDirectOnlineProcessSessionKey test
405 * @tc.type: FUNC
406 * @tc.require:
407 */
408 HWTEST_F(AuthOtherMockTest, AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001, TestSize.Level1)
409 {
410 AuthDeviceKeyInfo keyInfo = {
411 .keyLen = strlen("testKey"),
412 .isOldKey = true,
413 };
414 ASSERT_EQ(memcpy_s(keyInfo.deviceKey, SESSION_KEY_LENGTH, "testKey", strlen("testKey")), EOK);
415 AuthSessionInfo info = {
416 .connInfo.type = AUTH_LINK_TYPE_MAX,
417 };
418 int64_t authId = 0;
419 int32_t ret = AuthDirectOnlineProcessSessionKey(&info, &keyInfo, &authId);
420 EXPECT_EQ(ret, SOFTBUS_AUTH_SESSION_KEY_PROC_ERR);
421 }
422
423 /*
424 * @tc.name: FILL_AUTH_SESSION_INFO_TEST_001
425 * @tc.desc: FillAuthSessionInfo test failed
426 * @tc.type: FUNC
427 * @tc.require:
428 */
429 HWTEST_F(AuthOtherMockTest, FILL_AUTH_SESSION_INFO_TEST_001, TestSize.Level1)
430 {
431 AuthOtherInterfaceMock authMock;
432 EXPECT_CALL(authMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
433 AuthSessionInfo info = {
434 .connInfo.info.bleInfo.deviceIdHash = "123456789udidhashtest",
435 };
436 NodeInfo nodeInfo = {
437 .authCapacity = 127,
438 .uuid = "123456789uuidhashtest",
439 .deviceInfo.deviceUdid = "123456789udidtest",
440 };
441 AuthDeviceKeyInfo keyInfo;
442 (void)memset_s(&keyInfo, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
443 int32_t ret = FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, true);
444 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
445 }
446
447 /*
448 * @tc.name: AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001
449 * @tc.desc: AuthGetAuthHandleByIndex test
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 HWTEST_F(AuthOtherMockTest, AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001, TestSize.Level1)
454 {
455 AuthOtherInterfaceMock authMock;
456 EXPECT_CALL(authMock, LnnGetRemoteNodeInfoByKey).WillOnce(Return(SOFTBUS_OK))
457 .WillRepeatedly(AuthOtherInterfaceMock::ActionOfLnnGetRemoteNodeInfoByKey);
458
459 AuthConnInfo connInfo = {
460 .info.ipInfo.ip = "192.168.12.1",
461 .type = AUTH_LINK_TYPE_WIFI,
462 };
463 AuthHandle authHandle;
464 (void)memset_s(&authHandle, sizeof(AuthHandle), 0, sizeof(AuthHandle));
465
466 int32_t ret = AuthGetAuthHandleByIndex(&connInfo, true, INDEX, &authHandle);
467 EXPECT_EQ(ret, SOFTBUS_AUTH_NOT_SUPPORT_NORMALIZE);
468 ret = AuthGetAuthHandleByIndex(&connInfo, true, INDEX, &authHandle);
469 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
470 }
471
472 /*
473 * @tc.name: AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_002
474 * @tc.desc: AuthGetAuthHandleByIndex test
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(AuthOtherMockTest, AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_002, TestSize.Level1)
479 {
480 AuthOtherInterfaceMock authMock;
481 EXPECT_CALL(authMock, LnnGetNetworkIdByUdidHash).WillRepeatedly(Return(SOFTBUS_OK));
482 EXPECT_CALL(authMock, LnnGetRemoteNodeInfoByKey)
483 .WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
484
485 AuthConnInfo connInfo = {
486 .info.ipInfo.ip = "192.168.12.1",
487 .type = AUTH_LINK_TYPE_BLE,
488 };
489 AuthHandle authHandle;
490 (void)memset_s(&authHandle, sizeof(AuthHandle), 0, sizeof(AuthHandle));
491
492 char UDID_TEST[UDID_BUF_LEN] = "123456789udidtest";
493 connInfo.type = AUTH_LINK_TYPE_BLE;
494 ASSERT_EQ(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, UDID_TEST, strlen(UDID_TEST)), EOK);
495
496 int32_t ret = AuthGetAuthHandleByIndex(&connInfo, true, INDEX, &authHandle);
497 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
498
499 ret = AuthGetAuthHandleByIndex(&connInfo, true, INDEX, &authHandle);
500 EXPECT_EQ(ret, SOFTBUS_AUTH_NOT_SUPPORT_NORMALIZE);
501 }
502
503 /*
504 * @tc.name: AUTH_GET_P2P_CONN_INFO_TEST_001
505 * @tc.desc: AuthGetHmlConnInfo test failed
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(AuthOtherMockTest, AUTH_GET_P2P_CONN_INFO_TEST_001, TestSize.Level1)
510 {
511 AuthHandle authHandle = {
512 .authId = INDEX,
513 .type = AUTH_LINK_TYPE_MAX,
514 };
515 EXPECT_NO_FATAL_FAILURE(AuthRemoveAuthManagerByAuthHandle(authHandle));
516 authHandle.type = AUTH_LINK_TYPE_WIFI;
517 EXPECT_NO_FATAL_FAILURE(AuthRemoveAuthManagerByAuthHandle(authHandle));
518
519 AuthConnInfo connInfo = {
520 .info.ipInfo.ip = "192.168.12.1",
521 .type = AUTH_LINK_TYPE_BLE,
522 };
523
524 AuthOtherInterfaceMock authMock;
525 EXPECT_CALL(authMock, ConvertBytesToHexString)
526 .WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
527 EXPECT_NO_FATAL_FAILURE(PrintAuthConnInfo(nullptr));
528 EXPECT_NO_FATAL_FAILURE(PrintAuthConnInfo(&connInfo));
529
530 bool isMetaAuth = false;
531 const char *uuid = "000";
532 int32_t ret = AuthGetHmlConnInfo(uuid, &connInfo, isMetaAuth);
533 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
534 ret = AuthGetP2pConnInfo(uuid, &connInfo, isMetaAuth);
535 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
536 }
537
538 /*
539 * @tc.name: AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001
540 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(AuthOtherMockTest, AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001, TestSize.Level1)
545 {
546 AuthOtherInterfaceMock authMock;
547 EXPECT_CALL(authMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_INVALID_PARAM))
548 .WillRepeatedly(AuthOtherInterfaceMock::ActionOfLnnGetRemoteNodeInfoById);
549
550 const char *networkId = "123456456";
551 AuthConnInfo connInfo = {
552 .info.ipInfo.ip = "192.168.12.1",
553 .type = AUTH_LINK_TYPE_BLE,
554 };
555 int32_t ret = AuthCheckSessionKeyValidByConnInfo(nullptr, &connInfo);
556 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
557 ret = AuthCheckSessionKeyValidByConnInfo(networkId, nullptr);
558 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
559 ret = AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo);
560 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
561 ret = AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo);
562 EXPECT_EQ(ret, SOFTBUS_OK);
563 }
564
565 /*
566 * @tc.name: GET_IS_EXCHANGE_UDID_BY_NETWORKID_TEST_001
567 * @tc.desc: GetIsExchangeUdidByNetworkId test
568 * @tc.type: FUNC
569 * @tc.require:
570 */
571 HWTEST_F(AuthOtherMockTest, GET_IS_EXCHANGE_UDID_BY_NETWORKID_TEST_001, TestSize.Level1)
572 {
573 AuthOtherInterfaceMock authMock;
574 EXPECT_CALL(authMock, LnnRetrieveDeviceInfoByNetworkId).WillOnce(Return(SOFTBUS_INVALID_PARAM))
575 .WillRepeatedly(Return(SOFTBUS_OK));
576
577 bool isExchangeUdid = false;
578 const char *networkId = "networkId";
579 int32_t ret = GetIsExchangeUdidByNetworkId(nullptr, &isExchangeUdid);
580 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
581 ret = GetIsExchangeUdidByNetworkId(networkId, nullptr);
582 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
583 ret = GetIsExchangeUdidByNetworkId(networkId, &isExchangeUdid);
584 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
585 ret = GetIsExchangeUdidByNetworkId(networkId, &isExchangeUdid);
586 EXPECT_EQ(ret, SOFTBUS_OK);
587 }
588
589 /*
590 * @tc.name: GET_PEER_UDID_BY_NETWORK_ID_TEST_001
591 * @tc.desc: GetPeerUdidByNetworkId test failed
592 * @tc.type: FUNC
593 * @tc.require:
594 */
595 HWTEST_F(AuthOtherMockTest, GET_PEER_UDID_BY_NETWORK_ID_TEST_001, TestSize.Level1)
596 {
597 const char *networkId = "networkId";
598 char udid[UDID_BUF_LEN] = {0};
599 int32_t ret = GetPeerUdidByNetworkId(networkId, udid, TEST_DATA_LEN);
600 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
601 }
602
603 /*
604 * @tc.name: CONVERT_TO_AUTH_LINK_TYPE_TEST_001
605 * @tc.desc: ConvertToAuthLinkType test
606 * @tc.type: FUNC
607 * @tc.require:
608 */
609 HWTEST_F(AuthOtherMockTest, CONVERT_TO_AUTH_LINK_TYPE_TEST_001, TestSize.Level1)
610 {
611 DiscoveryType type = DISCOVERY_TYPE_UNKNOWN;
612 AuthLinkType ret = ConvertToAuthLinkType(type);
613 EXPECT_EQ(ret, AUTH_LINK_TYPE_MAX);
614
615 type = DISCOVERY_TYPE_WIFI;
616 ret = ConvertToAuthLinkType(type);
617 EXPECT_EQ(ret, AUTH_LINK_TYPE_WIFI);
618
619 type = DISCOVERY_TYPE_BLE;
620 ret = ConvertToAuthLinkType(type);
621 EXPECT_EQ(ret, AUTH_LINK_TYPE_BLE);
622
623 type = DISCOVERY_TYPE_BR;
624 ret = ConvertToAuthLinkType(type);
625 EXPECT_EQ(ret, AUTH_LINK_TYPE_BR);
626
627 type = DISCOVERY_TYPE_P2P;
628 ret = ConvertToAuthLinkType(type);
629 EXPECT_EQ(ret, AUTH_LINK_TYPE_P2P);
630 }
631
632 /*
633 * @tc.name: CONVERT_TO_DISCOVERY_TYPE_TEST_001
634 * @tc.desc: ConvertToDiscoveryType test
635 * @tc.type: FUNC
636 * @tc.require:
637 */
638 HWTEST_F(AuthOtherMockTest, CONVERT_TO_DISCOVERY_TYPE_TEST_001, TestSize.Level1)
639 {
640 AuthLinkType type = AUTH_LINK_TYPE_WIFI;
641 DiscoveryType ret = ConvertToDiscoveryType(type);
642 EXPECT_EQ(ret, DISCOVERY_TYPE_WIFI);
643
644 type = AUTH_LINK_TYPE_BLE;
645 ret = ConvertToDiscoveryType(type);
646 EXPECT_EQ(ret, DISCOVERY_TYPE_BLE);
647
648 type = AUTH_LINK_TYPE_BR;
649 ret = ConvertToDiscoveryType(type);
650 EXPECT_EQ(ret, DISCOVERY_TYPE_BR);
651
652 type = AUTH_LINK_TYPE_P2P;
653 ret = ConvertToDiscoveryType(type);
654 EXPECT_EQ(ret, DISCOVERY_TYPE_P2P);
655
656 type = AUTH_LINK_TYPE_MAX;
657 ret = ConvertToDiscoveryType(type);
658 EXPECT_EQ(ret, DISCOVERY_TYPE_UNKNOWN);
659 }
660
661 /*
662 * @tc.name: GET_AUTH_CAPACITY_TEST_001
663 * @tc.desc: GetAuthCapacity test failed
664 * @tc.type: FUNC
665 * @tc.require:
666 */
667 HWTEST_F(AuthOtherMockTest, GET_AUTH_CAPACITY_TEST_001, TestSize.Level1)
668 {
669 AuthOtherInterfaceMock authMock;
670 EXPECT_CALL(authMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
671 uint32_t ret = GetAuthCapacity();
672 EXPECT_EQ(ret, AUTH_DEFAULT_VALUE);
673 }
674
675 /*
676 * @tc.name: GET_CONFIG_SUPPORT_AS_SERVER_TEST_001
677 * @tc.desc: GetConfigSupportAsServer test
678 * @tc.type: FUNC
679 * @tc.require:
680 */
681 HWTEST_F(AuthOtherMockTest, GET_CONFIG_SUPPORT_AS_SERVER_TEST_001, TestSize.Level1)
682 {
683 AuthOtherInterfaceMock authMock;
684 EXPECT_CALL(authMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
685 bool ret = GetConfigSupportAsServer();
686 EXPECT_FALSE(ret);
687 }
688
689 /*
690 * @tc.name: CONVERT_TO_AUTH_CONN_INFO_TEST_001
691 * @tc.desc: ConvertToAuthConnInfo test
692 * @tc.type: FUNC
693 * @tc.require:
694 */
695 HWTEST_F(AuthOtherMockTest, CONVERT_TO_AUTH_CONN_INFO_TEST_001, TestSize.Level1)
696 {
697 ConnectionInfo info = {
698 .type = CONNECT_TCP,
699 .socketInfo.protocol = LNN_PROTOCOL_BR,
700 };
701 AuthConnInfo connInfo;
702 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
703
704 int32_t ret = ConvertToAuthConnInfo(&info, &connInfo);
705 EXPECT_EQ(ret, SOFTBUS_AUTH_INVALID_PROTOCOL);
706
707 info.socketInfo.protocol = LNN_PROTOCOL_IP;
708 ret = ConvertToAuthConnInfo(&info, &connInfo);
709 EXPECT_EQ(ret, SOFTBUS_OK);
710
711 info.type = CONNECT_BR;
712 ret = ConvertToAuthConnInfo(&info, &connInfo);
713 EXPECT_EQ(ret, SOFTBUS_OK);
714
715 info.type = CONNECT_BLE;
716 ret = ConvertToAuthConnInfo(&info, &connInfo);
717 EXPECT_EQ(ret, SOFTBUS_OK);
718
719 info.type = CONNECT_TYPE_MAX;
720 ret = ConvertToAuthConnInfo(&info, &connInfo);
721 EXPECT_EQ(ret, SOFTBUS_AUTH_UNEXPECTED_CONN_TYPE);
722 }
723
724 /*
725 * @tc.name: CONVERT_TO_CONNECT_OPTION_TEST_001
726 * @tc.desc: ConvertToConnectOption test
727 * @tc.type: FUNC
728 * @tc.require:
729 */
730 HWTEST_F(AuthOtherMockTest, CONVERT_TO_CONNECT_OPTION_TEST_001, TestSize.Level1)
731 {
732 AuthConnInfo connInfo = {
733 .type = AUTH_LINK_TYPE_BR,
734 };
735 ConnectOption option;
736 (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
737
738 int32_t ret = ConvertToConnectOption(&connInfo, &option);
739 EXPECT_EQ(ret, SOFTBUS_OK);
740
741 connInfo.type = AUTH_LINK_TYPE_BLE;
742 ret = ConvertToConnectOption(&connInfo, &option);
743 EXPECT_EQ(ret, SOFTBUS_OK);
744
745 connInfo.type = AUTH_LINK_TYPE_P2P;
746 ret = ConvertToConnectOption(&connInfo, &option);
747 EXPECT_EQ(ret, SOFTBUS_OK);
748
749 connInfo.type = AUTH_LINK_TYPE_P2P;
750 ret = ConvertToConnectOption(&connInfo, &option);
751 EXPECT_EQ(ret, SOFTBUS_OK);
752
753 connInfo.type = AUTH_LINK_TYPE_MAX;
754 ret = ConvertToConnectOption(&connInfo, &option);
755 EXPECT_EQ(ret, SOFTBUS_AUTH_UNEXPECTED_CONN_TYPE);
756 }
757
758 /*
759 * @tc.name: COMPARE_SESSION_CONN_INFO_TEST_001
760 * @tc.desc: CompareSessionConnInfo test
761 * @tc.type: FUNC
762 * @tc.require:
763 */
764 HWTEST_F(AuthOtherMockTest, COMPARE_SESSION_CONN_INFO_TEST_001, TestSize.Level1)
765 {
766 AuthConnInfo connInfo1 = {
767 .type = AUTH_LINK_TYPE_SESSION,
768 .info.sessionInfo.connId = AUTH_DEFAULT_VALUE,
769 .info.sessionInfo.udid = "udid",
770 };
771 AuthConnInfo connInfo2 = {
772 .type = AUTH_LINK_TYPE_SESSION,
773 .info.sessionInfo.connId = AUTH_DEFAULT_VALUE,
774 .info.sessionInfo.udid = "udid",
775 };
776 bool cmpShortHash = false;
777
778 bool ret = CompareConnInfo(&connInfo1, &connInfo2, cmpShortHash);
779 EXPECT_TRUE(ret);
780 connInfo2.info.sessionInfo.connId = INDEX;
781 ret = CompareConnInfo(&connInfo1, &connInfo2, cmpShortHash);
782 EXPECT_FALSE(ret);
783 }
784 } // namespace OHOS
785