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 <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "auth_log.h"
21 #include "auth_apply_key_manager.h"
22 #include "auth_apply_key_process.c"
23 #include "auth_apply_key_process.h"
24 #include "auth_apply_key_process_mock.h"
25 #include "lnn_distributed_net_ledger.h"
26 #include "lnn_local_net_ledger.h"
27 #include "lnn_net_ledger.h"
28 #include "message_handler.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_conn_manager_struct.h"
31
32 namespace OHOS {
33 using namespace testing;
34 using namespace testing::ext;
35 constexpr char NODE1_ACCOUNT_HASH[D2D_ACCOUNT_HASH_STR_LEN] = "abcd";
36 constexpr char NODE1_UDID_HASH[] = "123";
37 constexpr char TEST_DATA[] = "testdata";
38 constexpr uint8_t TEST_APPLY_KEY_DATA[] = "apply_key_data";
39 constexpr uint64_t APPLY_KEY_DECAY_TIME = 15552000000;
40 constexpr uint32_t AUTH_CONN_DATA_HEAD_SIZE = 24;
41 int32_t g_ret = 0;
42
43 class AuthApplyKeyProcessTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase()51 void AuthApplyKeyProcessTest::SetUpTestCase()
52 {
53 AUTH_LOGI(AUTH_CONN, "AuthApplyKeyProcessTest start");
54 }
55
TearDownTestCase()56 void AuthApplyKeyProcessTest::TearDownTestCase()
57 {
58 AUTH_LOGI(AUTH_CONN, "AuthApplyKeyProcessTest end");
59 }
60
SetUp()61 void AuthApplyKeyProcessTest::SetUp() { }
62
TearDown()63 void AuthApplyKeyProcessTest::TearDown() { }
64
OnGenSuccessTest(uint32_t requestId,uint8_t * applyKey,uint32_t applyKeyLen)65 static void OnGenSuccessTest(uint32_t requestId, uint8_t *applyKey, uint32_t applyKeyLen)
66 {
67 AUTH_LOGI(AUTH_CONN, "OnGenSuccessTest called");
68 (void)requestId;
69 (void)applyKey;
70 (void)applyKeyLen;
71 }
72
OnGenFailedTest(uint32_t requestId,int32_t reason)73 static void OnGenFailedTest(uint32_t requestId, int32_t reason)
74 {
75 AUTH_LOGI(AUTH_CONN, "OnGenFailedTest called");
76 (void)requestId;
77 (void)reason;
78 }
79
80 /*
81 * @tc.name: REQUIRE_APPLY_KEY_NEGO_LIST_LOCK_Test_001
82 * @tc.desc: RequireApplyKeyNegoListLock test2
83 * @tc.type: FUNC
84 * @tc.require:
85 */
86 HWTEST_F(AuthApplyKeyProcessTest, REQUIRE_APPLY_KEY_NEGO_LIST_LOCK_Test_001, TestSize.Level1)
87 {
88 bool ret = RequireApplyKeyNegoListLock();
89 EXPECT_EQ(ret, false);
90 ReleaseApplyKeyNegoListLock();
91 }
92
93 /*
94 * @tc.name: INIT_APPLY_KEY_NEGO_INSTANCE_LIST_Test_001
95 * @tc.desc: InitApplyKeyNegoInstanceList test
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(AuthApplyKeyProcessTest, INIT_APPLY_KEY_NEGO_INSTANCE_LIST_Test_001, TestSize.Level1)
100 {
101 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
102 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
103 DeInitApplyKeyNegoInstanceList();
104 int32_t ret = InitApplyKeyNegoInstanceList();
105 EXPECT_EQ(ret, SOFTBUS_OK);
106 DeInitApplyKeyNegoInstanceList();
107 ret = ApplyKeyNegoInit();
108 EXPECT_EQ(ret, SOFTBUS_OK);
109 ApplyKeyNegoDeinit();
110 }
111
112 /*
113 * @tc.name: GET_SAMPLE_APPLY_KEY_INSTANCE_NUM_Test_001
114 * @tc.desc: Get applyKeyInstance number by same info test
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(AuthApplyKeyProcessTest, GET_SAMPLE_APPLY_KEY_INSTANCE_NUM_Test_001, TestSize.Level1)
119 {
120 RequestBusinessInfo info;
121 uint32_t requestId = 0;
122 uint32_t connId = 0;
123 GenApplyKeyCallback cb;
124 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
125 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
126 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
127 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
128 uint32_t num = GetSameApplyKeyInstanceNum(&info);
129 EXPECT_EQ(num, 0);
130 DeleteApplyKeyNegoInstance(requestId);
131 int32_t ret = InitApplyKeyNegoInstanceList();
132 EXPECT_EQ(ret, SOFTBUS_OK);
133 num = GetSameApplyKeyInstanceNum(&info);
134 EXPECT_EQ(num, 0);
135 DeleteApplyKeyNegoInstance(requestId);
136 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
137 ret = CreateApplyKeyNegoInstance(&info, requestId, connId, true, nullptr);
138 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
139 ret = CreateApplyKeyNegoInstance(&info, requestId, connId, true, &cb);
140 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
141 ret = ApplyKeyNegoInit();
142 EXPECT_EQ(ret, SOFTBUS_OK);
143 num = GetSameApplyKeyInstanceNum(&info);
144 EXPECT_EQ(num, 0);
145 EXPECT_EQ(strcpy_s(info.accountHash, D2D_ACCOUNT_HASH_STR_LEN, NODE1_ACCOUNT_HASH), EOK);
146 EXPECT_EQ(strcpy_s(info.udidHash, D2D_UDID_HASH_STR_LEN, NODE1_UDID_HASH), EOK);
147 ret = CreateApplyKeyNegoInstance(&info, requestId, connId, true, &cb);
148 EXPECT_EQ(ret, SOFTBUS_OK);
149 ret = SetApplyKeyStartState(requestId, GEN_APPLY_KEY_STATE_START);
150 EXPECT_EQ(ret, SOFTBUS_OK);
151 num = GetSameApplyKeyInstanceNum(&info);
152 EXPECT_EQ(num, 1);
153 DeleteApplyKeyNegoInstance(requestId + 1);
154 DeleteApplyKeyNegoInstance(requestId);
155 ApplyKeyNegoDeinit();
156 }
157
158 /*
159 * @tc.name: GET_GEN_APPLY_KEY_INSTANCE_BY_REQ_Test_001
160 * @tc.desc: Get applyKeyInstance by req test
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(AuthApplyKeyProcessTest, GET_GEN_APPLY_KEY_INSTANCE_BY_REQ_Test_001, TestSize.Level1)
165 {
166 uint32_t requestId = 0;
167 uint32_t connId = 0;
168 ApplyKeyNegoInstance instance;
169 RequestBusinessInfo info;
170 GenApplyKeyCallback cb;
171 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
172 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
173 (void)memset_s(&instance, sizeof(instance), 0, sizeof(instance));
174 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
175 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
176 int32_t ret = GetGenApplyKeyInstanceByReq(requestId, &instance);
177 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
178 ret = InitApplyKeyNegoInstanceList();
179 EXPECT_EQ(ret, SOFTBUS_OK);
180 ret = GetGenApplyKeyInstanceByReq(requestId, nullptr);
181 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
182 ret = GetGenApplyKeyInstanceByReq(requestId, &instance);
183 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
184 ret = ApplyKeyNegoInit();
185 EXPECT_EQ(ret, SOFTBUS_OK);
186 ret = GetGenApplyKeyInstanceByReq(requestId, &instance);
187 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
188 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
189 ret = CreateApplyKeyNegoInstance(&info, requestId, connId, true, &cb);
190 EXPECT_EQ(ret, SOFTBUS_OK);
191 ret = GetGenApplyKeyInstanceByReq(requestId + 1, &instance);
192 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
193 ret = GetGenApplyKeyInstanceByReq(requestId, &instance);
194 EXPECT_EQ(ret, SOFTBUS_OK);
195 ApplyKeyNegoDeinit();
196 }
197
198 /*
199 * @tc.name: GET_GEN_APPLY_KEY_INSTANCE_BY_CHANNEL_Test_001
200 * @tc.desc: Get applyKeyInstance by channel test
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(AuthApplyKeyProcessTest, GET_GEN_APPLY_KEY_INSTANCE_BY_CHANNEL_Test_001, TestSize.Level1)
205 {
206 int32_t channelId = 0;
207 uint32_t requestId = 0;
208 ApplyKeyNegoInstance instance;
209 GenApplyKeyCallback cb;
210 RequestBusinessInfo info;
211 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
212 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
213 (void)memset_s(&instance, sizeof(instance), 0, sizeof(instance));
214 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
215 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
216 int32_t ret = GetGenApplyKeyInstanceByChannel(channelId, &instance);
217 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
218 ret = InitApplyKeyNegoInstanceList();
219 EXPECT_EQ(ret, SOFTBUS_OK);
220 ret = GetGenApplyKeyInstanceByChannel(channelId, nullptr);
221 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
222 ret = GetGenApplyKeyInstanceByChannel(channelId, &instance);
223 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
224 ret = ApplyKeyNegoInit();
225 EXPECT_EQ(ret, SOFTBUS_OK);
226 ret = GetGenApplyKeyInstanceByChannel(channelId, &instance);
227 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
228 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
229 ret = CreateApplyKeyNegoInstance(&info, requestId, channelId, true, &cb);
230 EXPECT_EQ(ret, SOFTBUS_OK);
231 ret = GetGenApplyKeyInstanceByChannel(channelId + 1, &instance);
232 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
233 ret = GetGenApplyKeyInstanceByChannel(channelId, &instance);
234 EXPECT_EQ(ret, SOFTBUS_OK);
235 ApplyKeyNegoDeinit();
236 }
237
238 /*
239 * @tc.name: SET_APPLY_KEY_NEGO_INFO_Test_001
240 * @tc.desc: set apply key instance info test
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(AuthApplyKeyProcessTest, SET_APPLY_KEY_NEGO_INFO_Test_001, TestSize.Level1)
245 {
246 uint32_t requestId = 0;
247 int32_t channelId = 0;
248 ApplyKeyNegoInstance instance;
249 GenApplyKeyCallback cb;
250 RequestBusinessInfo info;
251 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
252 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
253 EXPECT_CALL(authApplyKeyMock, AuthInsertApplyKey).WillRepeatedly(Return(SOFTBUS_OK));
254 (void)memset_s(&instance, sizeof(instance), 0, sizeof(instance));
255 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
256 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
257 char accountHash[SHA_256_HEX_HASH_LEN] = { 0 };
258 EXPECT_EQ(strcpy_s(accountHash, SHA_256_HEX_HASH_LEN, NODE1_ACCOUNT_HASH), EOK);
259 uint8_t sessionKey[D2D_APPLY_KEY_LEN] = { 0 };
260
261 int32_t ret = SetApplyKeyNegoInfoRecvSessionKey(requestId, true, sessionKey, D2D_APPLY_KEY_LEN);
262 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
263 ret = SetApplyKeyNegoInfoRecvFinish(requestId, true, accountHash);
264 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
265 ret = InitApplyKeyNegoInstanceList();
266 EXPECT_EQ(ret, SOFTBUS_OK);
267 ret = SetApplyKeyNegoInfoRecvSessionKey(requestId, true, sessionKey, D2D_APPLY_KEY_LEN);
268 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
269 ret = SetApplyKeyNegoInfoRecvFinish(requestId, true, accountHash);
270 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
271 ret = ApplyKeyNegoInit();
272 EXPECT_EQ(ret, SOFTBUS_OK);
273 ret = SetApplyKeyNegoInfoRecvSessionKey(requestId, true, sessionKey, D2D_APPLY_KEY_LEN);
274 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
275 ret = SetApplyKeyNegoInfoRecvFinish(requestId, true, accountHash);
276 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
277 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
278 ret = CreateApplyKeyNegoInstance(&info, requestId, channelId, true, &cb);
279 EXPECT_EQ(ret, SOFTBUS_OK);
280 ret = SetApplyKeyNegoInfoRecvSessionKey(requestId, true, sessionKey, D2D_APPLY_KEY_LEN);
281 EXPECT_EQ(ret, SOFTBUS_OK);
282 ret = SetApplyKeyNegoInfoRecvFinish(requestId, true, accountHash);
283 EXPECT_EQ(ret, SOFTBUS_OK);
284 ApplyKeyNegoDeinit();
285 }
286
287 /*
288 * @tc.name: SET_APPLY_KEY_STAR_STATE_Test_001
289 * @tc.desc: set apply key instance state test
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(AuthApplyKeyProcessTest, SET_APPLY_KEY_STAR_STATE_Test_001, TestSize.Level1)
294 {
295 uint32_t requestId = 0;
296 int32_t channelId = 0;
297 ApplyKeyNegoInstance instance;
298 GenApplyKeyCallback cb;
299 RequestBusinessInfo info;
300 GenApplyKeyStartState state = GEN_APPLY_KEY_STATE_START;
301 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
302 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
303 (void)memset_s(&instance, sizeof(instance), 0, sizeof(instance));
304 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
305 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
306 int32_t ret = SetApplyKeyStartState(requestId, state);
307 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
308 ret = InitApplyKeyNegoInstanceList();
309 EXPECT_EQ(ret, SOFTBUS_OK);
310 ret = SetApplyKeyStartState(requestId, state);
311 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
312 ret = ApplyKeyNegoInit();
313 EXPECT_EQ(ret, SOFTBUS_OK);
314 ret = SetApplyKeyStartState(requestId, state);
315 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_INSTANCE_NOT_FOUND);
316 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
317 ret = CreateApplyKeyNegoInstance(&info, requestId, channelId, true, &cb);
318 EXPECT_EQ(ret, SOFTBUS_OK);
319 ret = SetApplyKeyStartState(requestId, state);
320 EXPECT_EQ(ret, SOFTBUS_OK);
321 ApplyKeyNegoDeinit();
322 }
323
324 /*
325 * @tc.name: AUTH_FIND_APPLY_KEY_Test_001
326 * @tc.desc: Find ApplyKey by businessInfo test
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(AuthApplyKeyProcessTest, AUTH_FIND_APPLY_KEY_Test_001, TestSize.Level1)
331 {
332 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
333 RequestBusinessInfo info;
334 uint8_t applyKey[D2D_APPLY_KEY_LEN];
335 char accountHash[SHA_256_HEX_HASH_LEN] = { 0 };
336 EXPECT_EQ(strcpy_s(accountHash, SHA_256_HEX_HASH_LEN, NODE1_ACCOUNT_HASH), EOK);
337
338 int32_t ret = AuthFindApplyKey(nullptr, applyKey, accountHash, SHA_256_HEX_HASH_LEN);
339 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
340
341 EXPECT_CALL(authApplyKeyMock, GetApplyKeyByBusinessInfo).WillOnce(Return(SOFTBUS_AUTH_APPLY_KEY_NOT_FOUND));
342 ret = AuthFindApplyKey(&info, applyKey, accountHash, SHA_256_HEX_HASH_LEN);
343 EXPECT_EQ(ret, SOFTBUS_AUTH_APPLY_KEY_NOT_FOUND);
344
345 EXPECT_CALL(authApplyKeyMock, GetApplyKeyByBusinessInfo).WillOnce(Return(SOFTBUS_OK));
346 ret = AuthFindApplyKey(&info, applyKey, accountHash, SHA_256_HEX_HASH_LEN);
347 EXPECT_EQ(ret, SOFTBUS_OK);
348 }
349
350 /*
351 * @tc.name: AUTH_GEN_APPLY_KEY_ID_Test_001
352 * @tc.desc: Get ApplyKey by businessInfo test
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(AuthApplyKeyProcessTest, AUTH_GEN_APPLY_KEY_ID_Test_001, TestSize.Level1)
357 {
358 RequestBusinessInfo info;
359 uint32_t requestId = 1;
360 uint32_t connId = 1;
361 GenApplyKeyCallback genCb;
362 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
363 int32_t ret = AuthGenApplyKey(nullptr, requestId, connId, &genCb);
364 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
365 ret = AuthGenApplyKey(&info, requestId, connId, nullptr);
366 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
367 ret = AuthGenApplyKey(&info, requestId, connId, &genCb);
368 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
369 }
370
startLightAccountAuthStub(int32_t osAccountId,int64_t requestId,const char * serviceId,const DeviceAuthCallback * laCallBack)371 int32_t startLightAccountAuthStub(int32_t osAccountId, int64_t requestId, const char *serviceId,
372 const DeviceAuthCallback *laCallBack)
373 {
374 (void)osAccountId;
375 (void)requestId;
376 (void)serviceId;
377 (void)laCallBack;
378
379 return SOFTBUS_ERR;
380 }
381
processLightAccountAuthStub(int32_t osAccountId,int64_t requestId,DataBuff * inMsg,const DeviceAuthCallback * laCallBack)382 int32_t processLightAccountAuthStub(int32_t osAccountId, int64_t requestId, DataBuff *inMsg,
383 const DeviceAuthCallback *laCallBack)
384 {
385 (void)osAccountId;
386 (void)requestId;
387 (void)inMsg;
388 (void)laCallBack;
389
390 return SOFTBUS_ERR;
391 }
392
393 /*
394 * @tc.name: ON_COMM_DATA_RECEIVED_Test_001
395 * @tc.desc: Received Data process test
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399 HWTEST_F(AuthApplyKeyProcessTest, ON_COMM_DATA_RECEIVED_Test_001, TestSize.Level1)
400 {
401 uint32_t connectionId = 0;
402 ConnModule moduleId = MODULE_SLE_AUTH_CMD;
403 int64_t seq = 1;
404 const char *data = "123456";
405 int32_t len = 7;
406 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
407 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
408 int32_t ret = ApplyKeyNegoInit();
409 EXPECT_EQ(ret, SOFTBUS_OK);
410 OnCommDataReceived(connectionId, moduleId, seq, (char *)data, len);
411 AuthDataHead head;
412 uint8_t body = '1';
413 head.dataType = DATA_TYPE_DEVICE_ID;
414 head.seq = 1;
415 EXPECT_CALL(authApplyKeyMock, UnpackAuthData).WillRepeatedly(DoAll(SetArgPointee<2>(head), Return(&body)));
416 EXPECT_CALL(authApplyKeyMock, GetJsonObjectStringItem).WillRepeatedly(Return(true));
417 EXPECT_CALL(authApplyKeyMock, GetJsonObjectNumberItem).WillRepeatedly(Return(true));
418 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
419 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
420 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
421 moduleId = MODULE_APPLY_KEY_CONNECTION;
422 OnCommDataReceived(connectionId, moduleId, seq, (char *)data, len);
423 head.dataType = DATA_TYPE_AUTH;
424 LightAccountVerifier accountVerifier;
425 accountVerifier.processLightAccountAuth = processLightAccountAuthStub;
426 EXPECT_CALL(authApplyKeyMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
427 EXPECT_CALL(authApplyKeyMock, GetLightAccountVerifierInstance).WillRepeatedly(Return(&accountVerifier));
428 OnCommDataReceived(connectionId, moduleId, seq, (char *)data, len);
429
430 ApplyKeyNegoDeinit();
431 }
432
433 /*
434 * @tc.name: ON_REQUEST_Test_001
435 * @tc.desc: OnRequest func test
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(AuthApplyKeyProcessTest, ON_REQUEST_Test_001, TestSize.Level1)
440 {
441 int64_t authSeq = 0;
442 int operationCode = 0;
443 const char *reqParams = "123456";
444 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
445
446 EXPECT_CALL(authApplyKeyMock, AddStringToJsonObject).WillOnce(Return(false)).
447 WillRepeatedly(Return(true));
448 char *msg = OnRequest(authSeq, operationCode, reqParams);
449 EXPECT_EQ(msg, nullptr);
450
451 msg = OnRequest(authSeq, operationCode, reqParams);
452 EXPECT_NE(msg, nullptr);
453 cJSON_free(msg);
454 }
455
456 /*
457 * @tc.name: ON_ERROR_Test_001
458 * @tc.desc: OnError func test
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(AuthApplyKeyProcessTest, ON_ERROR_Test_001, TestSize.Level1)
463 {
464 int64_t authSeq = 0;
465 int operationCode = 0;
466 int32_t errCode = 1;
467 const char *errorReturn = "123456";
468
469 EXPECT_NO_FATAL_FAILURE(OnError(authSeq, operationCode, errCode, errorReturn));
470 }
471
472 /*
473 * @tc.name: ON_FINISHED_Test_001
474 * @tc.desc: OnFinished func test
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(AuthApplyKeyProcessTest, ON_FINISHED_Test_001, TestSize.Level1)
479 {
480 int64_t authSeq = 0;
481 int operationCode = 0;
482 const char *returnData = "123456";
483 uint32_t requestId = 0;
484 int32_t channelId = 0;
485 GenApplyKeyCallback cb;
486 RequestBusinessInfo info;
487 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
488 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
489 int32_t ret = ApplyKeyNegoInit();
490 EXPECT_EQ(ret, SOFTBUS_OK);
491 EXPECT_CALL(authApplyKeyMock, GetJsonObjectStringItem).WillRepeatedly(Return(false));
492 OnFinished(authSeq, operationCode, returnData);
493 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
494 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
495 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
496 ret = CreateApplyKeyNegoInstance(&info, requestId, channelId, true, &cb);
497 EXPECT_EQ(ret, SOFTBUS_OK);
498 char returnData1[] = "{\"peerUserId\":\"3003131321323131132321\"}";
499 OnFinished(authSeq, operationCode, returnData1);
500 ApplyKeyNegoDeinit();
501 }
502
503 /*
504 * @tc.name: ON_SESSION_KEY_RETURNED_Test_001
505 * @tc.desc: OnSessionKeyReturned func test
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(AuthApplyKeyProcessTest, ON_SESSION_KEY_RETURNED_Test_001, TestSize.Level1)
510 {
511 int64_t authSeq = 0;
512 uint32_t sessionKeyLen = 5;
513 int32_t channelId = 0;
514 GenApplyKeyCallback cb;
515 RequestBusinessInfo info;
516 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
517 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
518 int32_t ret = ApplyKeyNegoInit();
519 EXPECT_EQ(ret, SOFTBUS_OK);
520 OnSessionKeyReturned(authSeq, nullptr, sessionKeyLen);
521 OnSessionKeyReturned(authSeq, TEST_APPLY_KEY_DATA, sizeof(TEST_APPLY_KEY_DATA));
522 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
523 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
524 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
525 ret = CreateApplyKeyNegoInstance(&info, authSeq, channelId, true, &cb);
526 EXPECT_EQ(ret, SOFTBUS_OK);
527 OnSessionKeyReturned(authSeq, TEST_APPLY_KEY_DATA, sizeof(TEST_APPLY_KEY_DATA));
528 OnSessionKeyReturned(authSeq, TEST_APPLY_KEY_DATA, sizeof(TEST_APPLY_KEY_DATA));
529
530 ApplyKeyNegoDeinit();
531 }
532
533 /*
534 * @tc.name: ON_SESSION_KEY_RETURNED_Test_001
535 * @tc.desc: OnTransmitted func test
536 * @tc.type: FUNC
537 * @tc.require:
538 */
539 HWTEST_F(AuthApplyKeyProcessTest, ON_TRANSMITTED_Test_001, TestSize.Level1)
540 {
541 int64_t authSeq = 0;
542 uint32_t len = 5;
543 int32_t channelId = 0;
544 GenApplyKeyCallback cb;
545 RequestBusinessInfo info;
546 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
547 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
548 int32_t ret = ApplyKeyNegoInit();
549 EXPECT_EQ(ret, SOFTBUS_OK);
550 bool isSuc = OnTransmitted(authSeq, nullptr, len);
551 EXPECT_EQ(isSuc, false);
552 isSuc = OnTransmitted(authSeq, TEST_APPLY_KEY_DATA, sizeof(TEST_APPLY_KEY_DATA));
553 EXPECT_EQ(isSuc, false);
554 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
555 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
556 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
557 ret = CreateApplyKeyNegoInstance(&info, authSeq, channelId, true, &cb);
558 EXPECT_EQ(ret, SOFTBUS_OK);
559 EXPECT_CALL(authApplyKeyMock, GetAuthDataSize).WillRepeatedly(Return(AUTH_CONN_DATA_HEAD_SIZE + len));
560 EXPECT_CALL(authApplyKeyMock, ConnGetHeadSize).WillRepeatedly(Return(sizeof(ConnPktHead)));
561 EXPECT_CALL(authApplyKeyMock, PackAuthData).WillOnce(Return(SOFTBUS_OK));
562 EXPECT_CALL(authApplyKeyMock, ConnPostBytes).WillOnce(Return(SOFTBUS_OK));
563 isSuc = OnTransmitted(authSeq, TEST_APPLY_KEY_DATA, sizeof(TEST_APPLY_KEY_DATA));
564 EXPECT_EQ(isSuc, true);
565
566 ApplyKeyNegoDeinit();
567 }
568
569 /*
570 * @tc.name: ON_GEN_FAILED_Test_001
571 * @tc.desc: OnGenFailed func test
572 * @tc.type: FUNC
573 * @tc.require:
574 */
575 HWTEST_F(AuthApplyKeyProcessTest, ON_GEN_FAILED_Test_001, TestSize.Level1)
576 {
577 uint32_t requestId = 0;
578 int32_t reason = 0;
579 int32_t channelId = 0;
580 GenApplyKeyCallback cb;
581 RequestBusinessInfo info;
582 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
583 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
584
585 int32_t ret = ApplyKeyNegoInit();
586 EXPECT_EQ(ret, SOFTBUS_OK);
587 OnGenFailed(requestId, reason);
588 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
589 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
590 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
591 ret = CreateApplyKeyNegoInstance(&info, requestId, channelId, true, &cb);
592 EXPECT_EQ(ret, SOFTBUS_OK);
593 GenApplyKeyTimeoutProcess(&requestId);
594
595 ApplyKeyNegoDeinit();
596 }
597
598 /*
599 * @tc.name: ON_GEN_SUCCESS_Test_001
600 * @tc.desc: OnGenSuccess func test
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(AuthApplyKeyProcessTest, ON_GEN_SUCCESS_Test_001, TestSize.Level1)
605 {
606 uint32_t requestId = 0;
607 int32_t channelId = 0;
608 GenApplyKeyCallback cb;
609 RequestBusinessInfo info;
610 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
611 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
612
613 int32_t ret = ApplyKeyNegoInit();
614 EXPECT_EQ(ret, SOFTBUS_OK);
615 OnGenSuccess(requestId);
616 (void)memset_s(&cb, sizeof(cb), 0, sizeof(cb));
617 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
618 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_OK));
619 ret = CreateApplyKeyNegoInstance(&info, requestId, channelId, true, &cb);
620 EXPECT_EQ(ret, SOFTBUS_OK);
621 OnGenSuccess(requestId);
622
623 ApplyKeyNegoDeinit();
624 }
625
626 /*
627 * @tc.name: POST_APPLY_KEY_DATA_Test_001
628 * @tc.desc: Post ApplyKey Data test
629 * @tc.type: FUNC
630 * @tc.require:
631 */
632 HWTEST_F(AuthApplyKeyProcessTest, POST_APPLY_KEY_DATA_Test_001, TestSize.Level1)
633 {
634 uint32_t connId = 0;
635 AuthDataHead head;
636 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
637 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
638 int32_t ret = PostApplyKeyData(connId, true, &head, nullptr);
639 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
640
641 EXPECT_CALL(authApplyKeyMock, GetAuthDataSize).WillRepeatedly(Return(AUTH_CONN_DATA_HEAD_SIZE + head.len));
642 EXPECT_CALL(authApplyKeyMock, ConnGetHeadSize).WillRepeatedly(Return(sizeof(ConnPktHead)));
643 EXPECT_CALL(authApplyKeyMock, PackAuthData).WillOnce(Return(SOFTBUS_NO_ENOUGH_DATA));
644 ret = PostApplyKeyData(connId, true, &head, TEST_APPLY_KEY_DATA);
645 EXPECT_EQ(ret, SOFTBUS_NO_ENOUGH_DATA);
646
647 EXPECT_CALL(authApplyKeyMock, PackAuthData).WillOnce(Return(SOFTBUS_OK));
648 EXPECT_CALL(authApplyKeyMock, ConnPostBytes).WillOnce(Return(SOFTBUS_OK));
649 ret = PostApplyKeyData(connId, true, &head, TEST_APPLY_KEY_DATA);
650 EXPECT_EQ(ret, SOFTBUS_OK);
651 }
652
653 /*
654 * @tc.name: APPLY_KEY_GET_LIGHT_ACCOUNT_Test_001
655 * @tc.desc: ApplyKey Get LightAccount Instance test
656 * @tc.type: FUNC
657 * @tc.require:
658 */
659 HWTEST_F(AuthApplyKeyProcessTest, APPLY_KEY_GET_LIGHT_ACCOUNT_Test_001, TestSize.Level1)
660 {
661 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
662 EXPECT_CALL(authApplyKeyMock, InitDeviceAuthService).WillOnce(Return(HC_ERR_ALLOC_MEMORY));
663 const LightAccountVerifier *verifier = ApplyKeyGetLightAccountInstance();
664 EXPECT_EQ(verifier, nullptr);
665 LightAccountVerifier *retVerifier = (LightAccountVerifier *)SoftBusCalloc(sizeof(LightAccountVerifier));
666 ASSERT_NE(retVerifier, nullptr);
667 EXPECT_CALL(authApplyKeyMock, InitDeviceAuthService).WillOnce(Return(HC_SUCCESS));
668 EXPECT_CALL(authApplyKeyMock, GetLightAccountVerifierInstance).WillOnce(Return(retVerifier));
669 verifier = ApplyKeyGetLightAccountInstance();
670 EXPECT_EQ(verifier, retVerifier);
671 SoftBusFree((void *)verifier);
672 }
673
StartLightAccountAuth(int32_t osAccountId,int64_t requestId,const char * serviceId,const DeviceAuthCallback * laCallBack)674 int32_t StartLightAccountAuth(int32_t osAccountId, int64_t requestId, const char *serviceId,
675 const DeviceAuthCallback *laCallBack)
676 {
677 return g_ret;
678 }
679
680 /*
681 * @tc.name: PROCES_AUTH_HICHAIN_PARAM_Test_001
682 * @tc.desc: Process AuthHichain Param test
683 * @tc.type: FUNC
684 * @tc.require:
685 */
686 HWTEST_F(AuthApplyKeyProcessTest, PROCES_AUTH_HICHAIN_PARAM_Test_001, TestSize.Level1)
687 {
688 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
689 LightAccountVerifier *retVerifier = (LightAccountVerifier *)SoftBusCalloc(sizeof(LightAccountVerifier));
690 ASSERT_NE(retVerifier, nullptr);
691 retVerifier->startLightAccountAuth = StartLightAccountAuth;
692 EXPECT_CALL(authApplyKeyMock, InitDeviceAuthService).WillRepeatedly(Return(HC_SUCCESS));
693 EXPECT_CALL(authApplyKeyMock, GetLightAccountVerifierInstance).WillRepeatedly(Return(retVerifier));
694 uint32_t requestId = 0;
695 g_ret = HC_ERROR;
696 int32_t ret = ProcessAuthHichainParam(requestId, nullptr);
697 EXPECT_EQ(ret, HC_ERROR);
698 g_ret = HC_SUCCESS;
699 ret = ProcessAuthHichainParam(requestId, nullptr);
700 EXPECT_EQ(ret, SOFTBUS_OK);
701 SoftBusFree((void *)retVerifier);
702 }
703
704 /*
705 * @tc.name: GET_UDID_AND_ACCOUNT_SHORT_HASH_Test_001
706 * @tc.desc: Get UdidAndAccount ShortHash test
707 * @tc.type: FUNC
708 * @tc.require:
709 */
710 HWTEST_F(AuthApplyKeyProcessTest, GET_UDID_AND_ACCOUNT_SHORT_HASH_Test_001, TestSize.Level1)
711 {
712 char localUdidShortHash[D2D_UDID_HASH_STR_LEN];
713 char localAccountShortHash[D2D_ACCOUNT_HASH_STR_LEN];
714 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
715 (void)memset_s(localUdidShortHash, D2D_UDID_HASH_STR_LEN, 0, D2D_UDID_HASH_STR_LEN);
716 (void)memset_s(localAccountShortHash, D2D_ACCOUNT_HASH_STR_LEN, 0, D2D_ACCOUNT_HASH_STR_LEN);
717 int32_t ret = GetUdidAndAccountShortHash(nullptr, 0, nullptr, 0);
718 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
719 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND));
720 ret = GetUdidAndAccountShortHash(
721 localUdidShortHash, D2D_UDID_HASH_STR_LEN, localAccountShortHash, D2D_ACCOUNT_HASH_STR_LEN);
722 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
723 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
724 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_ENCRYPT_ERR));
725 ret = GetUdidAndAccountShortHash(
726 localUdidShortHash, D2D_UDID_HASH_STR_LEN, localAccountShortHash, D2D_ACCOUNT_HASH_STR_LEN);
727 EXPECT_EQ(ret, SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR);
728 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
729 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
730 ret = GetUdidAndAccountShortHash(
731 localUdidShortHash, D2D_UDID_HASH_STR_LEN, localAccountShortHash, D2D_ACCOUNT_HASH_STR_LEN);
732 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
733 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillOnce(Return(SOFTBUS_OK));
734 ret = GetUdidAndAccountShortHash(
735 localUdidShortHash, D2D_UDID_HASH_STR_LEN, localAccountShortHash, D2D_ACCOUNT_HASH_STR_LEN);
736 EXPECT_EQ(ret, SOFTBUS_OK);
737 }
738
739 /*
740 * @tc.name: PACK_APPLY_KEY_ACL_PARAM_Test_001
741 * @tc.desc: Pack ApplyKey AclParam test
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(AuthApplyKeyProcessTest, PACK_APPLY_KEY_ACL_PARAM_Test_001, TestSize.Level1)
746 {
747 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
748 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
749 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_ENCRYPT_ERR));
750 EXPECT_CALL(authApplyKeyMock, AddStringToJsonObject).WillRepeatedly(Return(true));
751 char *data = PackApplyKeyAclParam(BUSINESS_TYPE_D2D);
752 EXPECT_EQ(data, nullptr);
753 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
754 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillOnce(Return(SOFTBUS_OK));
755 EXPECT_CALL(authApplyKeyMock, AddNumberToJsonObject).WillOnce(Return(false));
756 data = PackApplyKeyAclParam(BUSINESS_TYPE_D2D);
757 EXPECT_EQ(data, nullptr);
758 }
759
760 /*
761 * @tc.name: UNPACK_APPLY_KEY_ACL_PARAM_Test_001
762 * @tc.desc: Unpack ApplyKey AclParam test
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(AuthApplyKeyProcessTest, UNPACK_APPLY_KEY_ACL_PARAM_Test_001, TestSize.Level1)
767 {
768 RequestBusinessInfo info;
769 int32_t ret = UnpackApplyKeyAclParam(nullptr, 0, nullptr);
770 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
771 ret = UnpackApplyKeyAclParam(TEST_DATA, strlen(TEST_DATA), &info);
772 EXPECT_EQ(ret, SOFTBUS_CREATE_JSON_ERR);
773 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
774 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
775 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
776 EXPECT_CALL(authApplyKeyMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
777 EXPECT_CALL(authApplyKeyMock, AddStringToJsonObject).WillRepeatedly(Return(true));
778 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
779 char *data = PackApplyKeyAclParam(BUSINESS_TYPE_D2D);
780 EXPECT_NE(data, nullptr);
781 EXPECT_CALL(authApplyKeyMock, GetJsonObjectStringItem).WillRepeatedly(Return(true));
782 EXPECT_CALL(authApplyKeyMock, GetJsonObjectNumberItem).WillRepeatedly(Return(true));
783 ret = UnpackApplyKeyAclParam(data, strlen(data), &info);
784 EXPECT_EQ(ret, SOFTBUS_OK);
785 ret = ProcessApplyKeyDeviceId(0, 0, data, strlen(data));
786 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
787 }
788
789 /*
790 * @tc.name: SEND_APPLY_KEY_NEGO_DEVICE_ID_Test_001
791 * @tc.desc: Send ApplyKey Nego DeviceId test
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(AuthApplyKeyProcessTest, SEND_APPLY_KEY_NEGO_DEVICE_ID_Test_001, TestSize.Level1)
796 {
797 uint32_t connId = 0;
798 RequestBusinessInfo info;
799 uint32_t requestId = 0;
800 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
801 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
802 int32_t ret = SendApplyKeyNegoDeviceId(connId, nullptr, requestId);
803 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
804 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND));
805 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
806 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
807 EXPECT_CALL(authApplyKeyMock, AddStringToJsonObject).WillRepeatedly(Return(true));
808 EXPECT_CALL(authApplyKeyMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
809 EXPECT_CALL(authApplyKeyMock, GetAuthDataSize).WillRepeatedly(Return(AUTH_CONN_DATA_HEAD_SIZE));
810 EXPECT_CALL(authApplyKeyMock, ConnGetHeadSize).WillRepeatedly(Return(sizeof(ConnPktHead)));
811 EXPECT_CALL(authApplyKeyMock, PackAuthData).WillRepeatedly(Return(SOFTBUS_OK));
812 EXPECT_CALL(authApplyKeyMock, ConnPostBytes).WillRepeatedly(Return(SOFTBUS_OK));
813 ret = SendApplyKeyNegoDeviceId(connId, &info, requestId);
814 EXPECT_EQ(ret, SOFTBUS_CREATE_JSON_ERR);
815 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
816 ret = SendApplyKeyNegoDeviceId(connId, &info, requestId);
817 EXPECT_EQ(ret, SOFTBUS_OK);
818 }
819
820 /*
821 * @tc.name: PROCESS_APPLY_KEY_NEGO_STATE_Test_001
822 * @tc.desc: Process ApplyKey NegoState test
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(AuthApplyKeyProcessTest, PROCESS_APPLY_KEY_NEGO_STATE_Test_001, TestSize.Level1)
827 {
828 RequestBusinessInfo info;
829 bool isGreater;
830 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
831 int32_t ret = ProcessApplyKeyNegoState(nullptr, &isGreater);
832 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
833 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND));
834 ret = ProcessApplyKeyNegoState(&info, &isGreater);
835 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
836 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
837 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
838 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
839 ret = ProcessApplyKeyNegoState(&info, &isGreater);
840 EXPECT_EQ(ret, SOFTBUS_OK);
841 }
842
843 /*
844 * @tc.name: START_APPLY_KEY_HICHAIN_Test_001
845 * @tc.desc: Start ApplyKey Hichain test
846 * @tc.type: FUNC
847 * @tc.require:
848 */
849 HWTEST_F(AuthApplyKeyProcessTest, START_APPLY_KEY_HICHAIN_Test_001, TestSize.Level1)
850 {
851 uint32_t connId = 0;
852 RequestBusinessInfo info;
853 uint32_t requestId = 0;
854 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
855 int32_t ret = StartApplyKeyHichain(connId, nullptr, requestId);
856 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
857 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND));
858 ret = StartApplyKeyHichain(connId, &info, requestId);
859 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
860 }
861
862 /*
863 * @tc.name: PROCESS_APPLY_KEY_DEVICE_ID_Test_001
864 * @tc.desc: Process ApplyKey DeviceId test
865 * @tc.type: FUNC
866 * @tc.require:
867 */
868 HWTEST_F(AuthApplyKeyProcessTest, PROCESS_APPLY_KEY_DEVICE_ID_Test_001, TestSize.Level1)
869 {
870 int32_t channelId = 0;
871 uint32_t requestId = 0;
872 int32_t ret = ProcessApplyKeyDeviceId(channelId, requestId, nullptr, 0);
873 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
874 }
875
876 /*
877 * @tc.name: PROCESS_APPLY_KEY_DATA_Test_001
878 * @tc.desc: Process ApplyKey Data test
879 * @tc.type: FUNC
880 * @tc.require:
881 */
882 HWTEST_F(AuthApplyKeyProcessTest, PROCESS_APPLY_KEY_DATA_Test_001, TestSize.Level1)
883 {
884 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
885 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
886 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
887 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
888 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
889 EXPECT_CALL(authApplyKeyMock, AddStringToJsonObject).WillRepeatedly(Return(true));
890 EXPECT_CALL(authApplyKeyMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
891 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
892 EXPECT_CALL(authApplyKeyMock, GetAuthDataSize).WillRepeatedly(Return(AUTH_CONN_DATA_HEAD_SIZE));
893 EXPECT_CALL(authApplyKeyMock, ConnGetHeadSize).WillRepeatedly(Return(sizeof(ConnPktHead)));
894 EXPECT_CALL(authApplyKeyMock, PackAuthData).WillRepeatedly(Return(SOFTBUS_OK));
895 EXPECT_CALL(authApplyKeyMock, ConnPostBytes).WillRepeatedly(Return(SOFTBUS_OK));
896 LightAccountVerifier accountVerifier;
897 accountVerifier.processLightAccountAuth = processLightAccountAuthStub;
898 EXPECT_CALL(authApplyKeyMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
899 EXPECT_CALL(authApplyKeyMock, GetLightAccountVerifierInstance).WillRepeatedly(Return(&accountVerifier));
900 int32_t ret = ApplyKeyNegoInit();
901 EXPECT_EQ(ret, SOFTBUS_OK);
902 uint32_t requestId = GenApplyKeySeq();
903 GenApplyKeyCallback cb = {
904 .onGenSuccess = OnGenSuccessTest,
905 .onGenFailed = OnGenFailedTest,
906 };
907 RequestBusinessInfo info;
908 info.type = (RequestBusinessType)0;
909 EXPECT_EQ(strcpy_s(info.accountHash, D2D_ACCOUNT_HASH_STR_LEN, NODE1_ACCOUNT_HASH), EOK);
910 EXPECT_EQ(strcpy_s(info.udidHash, D2D_UDID_HASH_STR_LEN, NODE1_UDID_HASH), EOK);
911 ret = AuthGenApplyKey(&info, requestId, 0, &cb);
912 EXPECT_EQ(ret, SOFTBUS_OK);
913 ret = ProcessApplyKeyData(requestId, TEST_APPLY_KEY_DATA, sizeof(TEST_APPLY_KEY_DATA));
914 EXPECT_EQ(ret, SOFTBUS_ERR);
915 }
916
917 /*
918 * @tc.name: CREATE_INSTANCE_STATIC_FUNC_Test_001
919 * @tc.desc: create instance static func test
920 * @tc.type: FUNC
921 * @tc.require:
922 */
923 HWTEST_F(AuthApplyKeyProcessTest, CREATE_INSTANCE_STATIC_FUNC_Test_001, TestSize.Level1)
924 {
925 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
926 EXPECT_CALL(authApplyKeyMock, ConnSetConnectCallback).WillRepeatedly(Return(true));
927 EXPECT_CALL(authApplyKeyMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
928 EXPECT_CALL(authApplyKeyMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
929 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
930 EXPECT_CALL(authApplyKeyMock, LnnGetLocalByteInfo).WillRepeatedly(Return(SOFTBUS_OK));
931 EXPECT_CALL(authApplyKeyMock, GetAuthDataSize).WillRepeatedly(Return(AUTH_CONN_DATA_HEAD_SIZE));
932 EXPECT_CALL(authApplyKeyMock, ConnGetHeadSize).WillRepeatedly(Return(SOFTBUS_OK));
933 EXPECT_CALL(authApplyKeyMock, PackAuthData).WillRepeatedly(Return(SOFTBUS_OK));
934 EXPECT_CALL(authApplyKeyMock, ConnPostBytes).WillRepeatedly(Return(SOFTBUS_OK));
935 EXPECT_CALL(authApplyKeyMock, AddStringToJsonObject).WillRepeatedly(Return(true));
936 EXPECT_CALL(authApplyKeyMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
937 EXPECT_CALL(authApplyKeyMock, GetApplyKeyByBusinessInfo).WillRepeatedly(Return(SOFTBUS_OK));
938 LightAccountVerifier accountVerifier;
939 accountVerifier.processLightAccountAuth = processLightAccountAuthStub;
940 EXPECT_CALL(authApplyKeyMock, InitDeviceAuthService).WillRepeatedly(Return(SOFTBUS_OK));
941 EXPECT_CALL(authApplyKeyMock, GetLightAccountVerifierInstance).WillRepeatedly(Return(&accountVerifier));
942 uint32_t requestId = GenApplyKeySeq();
943 GenApplyKeyCallback cb = {
944 .onGenSuccess = OnGenSuccessTest,
945 .onGenFailed = OnGenFailedTest,
946 };
947 RequestBusinessInfo info;
948 info.type = (RequestBusinessType)0;
949 EXPECT_EQ(strcpy_s(info.accountHash, D2D_ACCOUNT_HASH_STR_LEN, NODE1_ACCOUNT_HASH), EOK);
950 EXPECT_EQ(strcpy_s(info.udidHash, D2D_UDID_HASH_STR_LEN, NODE1_UDID_HASH), EOK);
951 int32_t ret = AuthGenApplyKey(&info, requestId, 0, &cb);
952 EXPECT_EQ(ret, SOFTBUS_OK);
953 EXPECT_NO_FATAL_FAILURE(AsyncCallGenApplyKeyResultReceived(nullptr));
954 ret = CreateApplyKeyNegoInstance(&info, requestId, 0, true, &cb);
955 SyncGenApplyKeyResult *result = (SyncGenApplyKeyResult *)SoftBusCalloc(sizeof(SyncGenApplyKeyResult));
956 EXPECT_NE(result, nullptr);
957 result->requestId = requestId;
958 result->isGenApplyKeySuccess = true;
959 EXPECT_NO_FATAL_FAILURE(AsyncCallGenApplyKeyResultReceived((void *)result));
960 ret = CreateApplyKeyNegoInstance(&info, requestId, 0, true, &cb);
961 SyncGenApplyKeyResult *result1 = (SyncGenApplyKeyResult *)SoftBusCalloc(sizeof(SyncGenApplyKeyResult));
962 EXPECT_NE(result1, nullptr);
963 result1->requestId = requestId;
964 result1->isGenApplyKeySuccess = false;
965 EXPECT_NO_FATAL_FAILURE(AsyncCallGenApplyKeyResultReceived((void *)result1));
966 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(nullptr, true, 0));
967 ret = CreateApplyKeyNegoInstance(&info, requestId, 0, true, &cb);
968 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, true, 0));
969 ret = CreateApplyKeyNegoInstance(&info, requestId, 0, true, &cb);
970 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, false, 0));
971 info.type = (RequestBusinessType)1;
972 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, true, 0));
973 }
974
975 /*
976 * @tc.name: SOFTBUS_GENERATE_STR_HASH_FUNC_Test_001
977 * @tc.desc: SoftBusGenerateStrHash test
978 * @tc.type: FUNC
979 * @tc.require:
980 */
981 HWTEST_F(AuthApplyKeyProcessTest, SOFTBUS_GENERATE_STR_HASH_FUNC_Test_001, TestSize.Level1)
982 {
983 AuthApplyKeyProcessInterfaceMock authApplyKeyMock;
984 EXPECT_CALL(authApplyKeyMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
985 ConnectionInfo info;
986 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
987 EXPECT_NO_FATAL_FAILURE(OnCommConnected(0, &info));
988 EXPECT_NO_FATAL_FAILURE(OnCommDisconnected(0, &info));
989 char hichainReturnAccountId[SHA_256_HEX_HASH_LEN];
990 char hichainReturnAccountHash[SHA_256_HEX_HASH_LEN];
991 int32_t ret = GenerateAccountHash(hichainReturnAccountId, hichainReturnAccountHash, SHA_256_HEX_HASH_LEN);
992 EXPECT_EQ(ret, SOFTBUS_OK);
993 }
994
995 /*
996 * @tc.name: AUTH_IS_APPLY_KEY_EXPIRED_Test_001
997 * @tc.desc: AuthIsApplyKeyExpired test
998 * @tc.type: FUNC
999 * @tc.require:
1000 */
1001 HWTEST_F(AuthApplyKeyProcessTest, AUTH_IS_APPLY_KEY_EXPIRED_Test_001, TestSize.Level1)
1002 {
1003 bool ret = AuthIsApplyKeyExpired(0);
1004 EXPECT_FALSE(ret);
1005 uint64_t currentTime = SoftBusGetSysTimeMs();
1006 ret = AuthIsApplyKeyExpired(currentTime - APPLY_KEY_DECAY_TIME + 1);
1007 EXPECT_TRUE(ret);
1008 }
1009 } // namespace OHOS