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