1 /*
2 * Copyright (c) 2022-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 "UTTest_dm_auth_manager_second.h"
17
18 #include "auth_message_processor.h"
19 #include "device_manager_service_listener.h"
20 #include "dm_auth_manager.h"
21 #include "dm_anonymous.h"
22 #include "dm_constants.h"
23 #include "dm_crypto.h"
24 #include "dm_dialog_manager.h"
25 #include "dm_log.h"
26 #include "json_object.h"
27 #include "softbus_error_code.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31 namespace OHOS {
32 namespace DistributedHardware {
SetUp()33 void DmAuthManagerTest::SetUp()
34 {
35 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
36 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
37 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
38 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
39 authManager_ = std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
40 authManager_->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager_);
41 authManager_->authMessageProcessor_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
42 authManager_->authMessageProcessor_->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
43 authManager_->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
44 authManager_->authRequestState_ = std::make_shared<AuthRequestFinishState>();
45 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
46 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
47 authManager_->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
48 authManager_->softbusConnector_ = std::make_shared<SoftbusConnector>();
49 authManager_->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(
50 std::shared_ptr<ISoftbusSessionCallback>(authManager_));
51 authManager_->timer_ = std::make_shared<DmTimer>();
52 }
TearDown()53 void DmAuthManagerTest::TearDown()
54 {
55 authManager_ = nullptr;
56 }
SetUpTestCase()57 void DmAuthManagerTest::SetUpTestCase()
58 {
59 hiChainConnectorMock_ = std::make_shared<HiChainConnectorMock>();
60 DmHiChainConnector::dmHiChainConnector = hiChainConnectorMock_;
61 multipleUserConnectorMock_ = std::make_shared<MultipleUserConnectorMock>();
62 DmMultipleUserConnector::dmMultipleUserConnector = multipleUserConnectorMock_;
63 softbusConnectorMock_ = std::make_shared<SoftbusConnectorMock>();
64 DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock_;
65 hiChainAuthConnectorMock_ = std::make_shared<HiChainAuthConnectorMock>();
66 DmHiChainAuthConnector::dmHiChainAuthConnector = hiChainAuthConnectorMock_;
67 deviceProfileConnectorMock_ = std::make_shared<DeviceProfileConnectorMock>();
68 DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock_;
69 cryptoMock_ = std::make_shared<CryptoMock>();
70 DmCrypto::dmCrypto = cryptoMock_;
71 }
TearDownTestCase()72 void DmAuthManagerTest::TearDownTestCase()
73 {
74 DmHiChainConnector::dmHiChainConnector = nullptr;
75 hiChainConnectorMock_ = nullptr;
76 DmMultipleUserConnector::dmMultipleUserConnector = nullptr;
77 multipleUserConnectorMock_ = nullptr;
78 DmSoftbusConnector::dmSoftbusConnector = nullptr;
79 softbusConnectorMock_ = nullptr;
80 DmHiChainAuthConnector::dmHiChainAuthConnector = nullptr;
81 hiChainAuthConnectorMock_ = nullptr;
82 DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr;
83 deviceProfileConnectorMock_ = nullptr;
84 DmCrypto::dmCrypto = nullptr;
85 cryptoMock_ = nullptr;
86 }
87
88 namespace {
89 HWTEST_F(DmAuthManagerTest, OnDataReceived_001, testing::ext::TestSize.Level1)
90 {
91 int32_t sessionId = 0;
92 std::string message;
93 authManager_->authResponseContext_ = nullptr;
94 authManager_->OnDataReceived(sessionId, message);
95 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
96 }
97
98 HWTEST_F(DmAuthManagerTest, OnDataReceived_002, testing::ext::TestSize.Level1)
99 {
100 int32_t sessionId = 0;
101 std::string message;
102 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
103 authManager_->authMessageProcessor_ = nullptr;
104 authManager_->OnDataReceived(sessionId, message);
105 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
106 }
107
108 HWTEST_F(DmAuthManagerTest, OnDataReceived_003, testing::ext::TestSize.Level1)
109 {
110 int32_t sessionId = 0;
111 std::string message;
112 authManager_->OnDataReceived(sessionId, message);
113 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
114 }
115
116 HWTEST_F(DmAuthManagerTest, OnDataReceived_007, testing::ext::TestSize.Level1)
117 {
118 int32_t sessionId = 0;
119 JsonObject jsonObject;
120 jsonObject[TAG_MSG_TYPE] = 200;
121 std::string message = jsonObject.Dump();
122 authManager_->OnDataReceived(sessionId, message);
123 authManager_->authRequestState_ = nullptr;
124 authManager_->authResponseState_ = nullptr;
125 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
126 }
127
128 HWTEST_F(DmAuthManagerTest, OnGroupCreated_001, testing::ext::TestSize.Level1)
129 {
130 int64_t requestId = 0;
131 std::string groupId;
132 authManager_->authResponseContext_ = nullptr;
133 authManager_->OnGroupCreated(requestId, groupId);
134 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
135 }
136
137 HWTEST_F(DmAuthManagerTest, OnGroupCreated_002, testing::ext::TestSize.Level1)
138 {
139 int64_t requestId = 0;
140 std::string groupId;
141 authManager_->authResponseState_ = nullptr;
142 authManager_->OnGroupCreated(requestId, groupId);
143 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
144 }
145
146 HWTEST_F(DmAuthManagerTest, OnGroupCreated_003, testing::ext::TestSize.Level1)
147 {
148 int64_t requestId = 0;
149 std::string groupId = "{}";
150 authManager_->OnGroupCreated(requestId, groupId);
151 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
152 }
153
154 HWTEST_F(DmAuthManagerTest, OnGroupCreated_004, testing::ext::TestSize.Level1)
155 {
156 int64_t requestId = 0;
157 std::string groupId = "groupId";
158 authManager_->authResponseContext_->isShowDialog = true;
159 authManager_->OnGroupCreated(requestId, groupId);
160 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
161 }
162
163 HWTEST_F(DmAuthManagerTest, OnGroupCreated_005, testing::ext::TestSize.Level1)
164 {
165 int64_t requestId = 0;
166 std::string groupId = "groupId";
167 authManager_->authResponseContext_->isShowDialog = false;
168 authManager_->OnGroupCreated(requestId, groupId);
169 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
170 }
171
172 HWTEST_F(DmAuthManagerTest, OnMemberJoin_001, testing::ext::TestSize.Level1)
173 {
174 int64_t requestId = 0;
175 int32_t status = 11;
176 authManager_->authResponseContext_ = nullptr;
177 authManager_->OnMemberJoin(requestId, status, 0);
178 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
179 }
180
181 HWTEST_F(DmAuthManagerTest, OnMemberJoin_002, testing::ext::TestSize.Level1)
182 {
183 int64_t requestId = 0;
184 int32_t status = 11;
185 authManager_->authUiStateMgr_ = nullptr;
186 authManager_->OnMemberJoin(requestId, status, 0);
187 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
188 }
189
190 HWTEST_F(DmAuthManagerTest, OnMemberJoin_003, testing::ext::TestSize.Level1)
191 {
192 int64_t requestId = 0;
193 int32_t status = 11;
194 authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
195 authManager_->authResponseState_ = nullptr;
196 authManager_->authResponseContext_->authType = 5;
197 authManager_->OnMemberJoin(requestId, status, 0);
198 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
199 }
200
201 HWTEST_F(DmAuthManagerTest, OnMemberJoin_004, testing::ext::TestSize.Level1)
202 {
203 int64_t requestId = 0;
204 int32_t status = 11;
205 authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
206 authManager_->authResponseState_ = nullptr;
207 authManager_->authResponseContext_->authType = 6;
208 authManager_->authResponseContext_->requestId = 1;
209 authManager_->OnMemberJoin(requestId, status, 0);
210 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
211 }
212
213 HWTEST_F(DmAuthManagerTest, OnMemberJoin_006, testing::ext::TestSize.Level1)
214 {
215 int64_t requestId = 0;
216 int32_t status = 0;
217 authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
218 authManager_->authResponseState_ = nullptr;
219 authManager_->authResponseContext_->authType = 6;
220 authManager_->authResponseContext_->requestId = 0;
221 authManager_->OnMemberJoin(requestId, status, 0);
222 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
223 }
224
225 HWTEST_F(DmAuthManagerTest, OnMemberJoin_007, testing::ext::TestSize.Level1)
226 {
227 int64_t requestId = 0;
228 int32_t status = 0;
229 authManager_->authRequestState_ = nullptr;
230 authManager_->authResponseState_ = std::make_shared<AuthResponseShowState>();
231 authManager_->authResponseContext_->authType = 6;
232 authManager_->authResponseContext_->requestId = 0;
233 authManager_->OnMemberJoin(requestId, status, 0);
234 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
235 }
236
237 HWTEST_F(DmAuthManagerTest, OnMemberJoin_008, testing::ext::TestSize.Level1)
238 {
239 int64_t requestId = 0;
240 int32_t status = 0;
241 authManager_->authRequestState_ = nullptr;
242 authManager_->authResponseState_ = nullptr;
243 authManager_->OnMemberJoin(requestId, status, 0);
244 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
245 }
246
247 HWTEST_F(DmAuthManagerTest, OnMemberJoin_009, testing::ext::TestSize.Level1)
248 {
249 int64_t requestId = 0;
250 int32_t status = DM_OK;
251 authManager_->authRequestState_ = nullptr;
252 authManager_->authTimes_ = 1;
253 std::shared_ptr<AuthResponseInitStateMock> authResponseInitStateMock =
254 std::make_shared<AuthResponseInitStateMock>();
255 EXPECT_CALL(*authResponseInitStateMock, GetStateType())
256 .WillRepeatedly(testing::Return(AuthState::AUTH_RESPONSE_CREDENTIAL));
257 authManager_->authResponseState_ = authResponseInitStateMock;
258 authManager_->authResponseContext_->isFinish = true;
259 authManager_->authResponseContext_->requestId = 0;
260 authManager_->OnMemberJoin(requestId, status, 0);
261 ASSERT_TRUE(authManager_->authResponseContext_->isFinish);
262
263 authManager_->authResponseContext_->isFinish = true;
264 authManager_->authResponseContext_->requestId = 1;
265 authManager_->OnMemberJoin(requestId, status, 0);
266 ASSERT_FALSE(authManager_->authResponseContext_->isFinish);
267
268 authManager_->authResponseContext_->isFinish = true;
269 status = ERR_DM_FAILED;
270 authManager_->OnMemberJoin(requestId, status, 0);
271 ASSERT_FALSE(authManager_->authResponseContext_->isFinish);
272 }
273
274 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_001, testing::ext::TestSize.Level1)
275 {
276 int64_t requestId = 1;
277 int32_t status = 0;
278 authManager_->authResponseContext_->requestId = 1;
279 authManager_->HandleMemberJoinImportAuthCode(requestId, status);
280 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
281 }
282
283 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_002, testing::ext::TestSize.Level1)
284 {
285 int64_t requestId = 1;
286 int32_t status = 1;
287 authManager_->authResponseContext_->requestId = 1;
288 authManager_->HandleMemberJoinImportAuthCode(requestId, status);
289 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
290 }
291
292 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_003, testing::ext::TestSize.Level1)
293 {
294 int64_t requestId = 1;
295 int32_t status = 1;
296 authManager_->authResponseContext_->requestId = 0;
297 authManager_->HandleMemberJoinImportAuthCode(requestId, status);
298 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
299 }
300
301 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_004, testing::ext::TestSize.Level1)
302 {
303 int64_t requestId = 1;
304 int32_t status = 0;
305 authManager_->authResponseContext_->requestId = 0;
306 authManager_->HandleMemberJoinImportAuthCode(requestId, status);
307 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
308 }
309
310 HWTEST_F(DmAuthManagerTest, RespNegotiate_001, testing::ext::TestSize.Level1)
311 {
312 int64_t requestId = 1;
313 authManager_->authResponseContext_ = nullptr;
314 authManager_->RespNegotiate(requestId);
315 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
316 }
317
318 HWTEST_F(DmAuthManagerTest, RespNegotiate_002, testing::ext::TestSize.Level1)
319 {
320 int64_t requestId = 1;
321 authManager_->RespNegotiate(requestId);
322 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
323 }
324
325 HWTEST_F(DmAuthManagerTest, RespNegotiate_003, testing::ext::TestSize.Level1)
326 {
327 int64_t requestId = 1;
328 authManager_->authRequestState_ = nullptr;
329 authManager_->authResponseContext_->dmVersion = "dmVersion";
330 authManager_->authResponseContext_->bindLevel = 1;
331 authManager_->RespNegotiate(requestId);
332 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
333 }
334
335 HWTEST_F(DmAuthManagerTest, RespNegotiate_004, testing::ext::TestSize.Level1)
336 {
337 int64_t requestId = 1;
338 authManager_->authRequestState_ = nullptr;
339 authManager_->authResponseContext_->dmVersion = "";
340 authManager_->authResponseContext_->bindLevel = 0;
341 authManager_->RespNegotiate(requestId);
342 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
343 }
344
345 HWTEST_F(DmAuthManagerTest, RespNegotiate_005, testing::ext::TestSize.Level1)
346 {
347 int64_t requestId = 1;
348 authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
349 authManager_->authResponseContext_->dmVersion = "4.1.5.1";
350 authManager_->authResponseContext_->bindLevel = 0;
351 authManager_->RespNegotiate(requestId);
352 authManager_->authResponseContext_->dmVersion = "5.0.1";
353 authManager_->authResponseContext_->bindLevel = 1;
354 authManager_->RespNegotiate(requestId);
355 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
356 }
357
358 HWTEST_F(DmAuthManagerTest, SendAuthRequest_001, testing::ext::TestSize.Level1)
359 {
360 int64_t sessionId = 1;
361 authManager_->authResponseContext_ = nullptr;
362 authManager_->SendAuthRequest(sessionId);
363 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
364 }
365
366 HWTEST_F(DmAuthManagerTest, SendAuthRequest_002, testing::ext::TestSize.Level1)
367 {
368 int64_t sessionId = 1;
369 authManager_->authResponseContext_->cryptoSupport = true;
370 authManager_->authResponseContext_->dmVersion = "dmVersion";
371 authManager_->authResponseContext_->bindLevel = 1;
372 authManager_->authResponseContext_->hostPkgName = "hostPkgName";
373 authManager_->authResponseContext_->localDeviceId = "123456789";
374 authManager_->authResponseContext_->deviceId = "deviceId";
375 authManager_->authResponseContext_->reply = -20018;
376 authManager_->SendAuthRequest(sessionId);
377 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
378 }
379
380 HWTEST_F(DmAuthManagerTest, SendAuthRequest_003, testing::ext::TestSize.Level1)
381 {
382 int64_t sessionId = 1;
383 authManager_->authResponseContext_->cryptoSupport = true;
384 authManager_->authResponseContext_->bindLevel = 0;
385 authManager_->authResponseContext_->dmVersion = "dmVersion";
386 authManager_->authResponseContext_->bindLevel = 1;
387 authManager_->authResponseContext_->hostPkgName = "hostPkgName";
388 authManager_->authResponseContext_->localDeviceId = "123456789";
389 authManager_->authResponseContext_->deviceId = "deviceId";
390 authManager_->authResponseContext_->reply = -20018;
391 authManager_->SendAuthRequest(sessionId);
392 authManager_->authResponseContext_->dmVersion = "5.0.1";
393 authManager_->authResponseContext_->bindLevel = 0;
394 authManager_->SendAuthRequest(sessionId);
395 authManager_->authResponseContext_->dmVersion = "";
396 authManager_->authResponseContext_->bindLevel = 1;
397 authManager_->SendAuthRequest(sessionId);
398 authManager_->authResponseContext_->dmVersion = "5.0.1";
399 authManager_->authResponseContext_->bindLevel = 1;
400 authManager_->SendAuthRequest(sessionId);
401 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
402 }
403
404 HWTEST_F(DmAuthManagerTest, GetAuthRequestContext_001, testing::ext::TestSize.Level1)
405 {
406 authManager_->authResponseContext_->localDeviceId = "123456789";
407 authManager_->authResponseContext_->localDeviceId = "123456789";
408 authManager_->authResponseContext_->localAccountId = "123456789";
409 authManager_->authRequestContext_->remoteAccountId = "123456789";
410 authManager_->authRequestContext_->localAccountId = "123456789";
411 authManager_->authResponseContext_->localUserId = 123456789;
412 authManager_->GetAuthRequestContext();
413 authManager_->authResponseContext_->isOnline = false;
414 authManager_->GetAuthRequestContext();
415 authManager_->authResponseContext_->isOnline = true;
416 authManager_->authResponseContext_->haveCredential = true;
417 authManager_->GetAuthRequestContext();
418 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
419 }
420
421 HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_001, testing::ext::TestSize.Level1)
422 {
423 int32_t sessionId = 1;
424 authManager_->authResponseContext_->reply = -20018;
425 authManager_->ProcessAuthRequestExt(sessionId);
426 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
427 }
428
429 HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_002, testing::ext::TestSize.Level1)
430 {
431 int32_t sessionId = 1;
432 authManager_->authResponseContext_->reply = -200;
433 authManager_->authResponseContext_->isOnline = false;
434 authManager_->authResponseContext_->authed = false;
435 authManager_->authResponseContext_->isIdenticalAccount = true;
436 authManager_->ProcessAuthRequestExt(sessionId);
437 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
438 }
439
440 HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_004, testing::ext::TestSize.Level1)
441 {
442 int32_t sessionId = 1;
443 authManager_->authResponseContext_->reply = -200;
444 authManager_->authResponseContext_->authType = 5;
445 authManager_->authResponseContext_->isIdenticalAccount = false;
446 authManager_->authResponseContext_->isAuthCodeReady = false;
447 authManager_->ProcessAuthRequestExt(sessionId);
448 authManager_->authResponseContext_->isOnline = true;
449 authManager_->authResponseContext_->authed = true;
450 authManager_->ProcessAuthRequestExt(sessionId);
451 authManager_->authResponseContext_->authed = false;
452 authManager_->authResponseContext_->isOnline = false;
453 authManager_->ProcessAuthRequestExt(sessionId);
454 authManager_->authResponseContext_->isIdenticalAccount = true;
455 authManager_->ProcessAuthRequestExt(sessionId);
456 authManager_->authResponseContext_->isIdenticalAccount = false;
457 authManager_->authResponseContext_->authed = true;
458 authManager_->ProcessAuthRequestExt(sessionId);
459 authManager_->authResponseContext_->isOnline = true;
460 authManager_->ProcessAuthRequestExt(sessionId);
461 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
462 }
463
464 HWTEST_F(DmAuthManagerTest, ConfirmProcess_001, testing::ext::TestSize.Level1)
465 {
466 int32_t action = 1;
467 authManager_->action_ = 0;
468 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
469 int32_t ret = authManager_->ConfirmProcess(action);
470 ASSERT_EQ(ret, DM_OK);
471 }
472
473 HWTEST_F(DmAuthManagerTest, ConfirmProcess_002, testing::ext::TestSize.Level1)
474 {
475 int32_t action = 1;
476 authManager_->action_ = 6;
477 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
478 int32_t ret = authManager_->ConfirmProcess(action);
479 ASSERT_EQ(ret, DM_OK);
480 }
481
482 HWTEST_F(DmAuthManagerTest, ConfirmProcess_003, testing::ext::TestSize.Level1)
483 {
484 int32_t action = 3;
485 authManager_->action_ = 4;
486 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
487 int32_t ret = authManager_->ConfirmProcess(action);
488 ASSERT_EQ(ret, DM_OK);
489 }
490
491 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_001, testing::ext::TestSize.Level1)
492 {
493 int32_t action = 1;
494 authManager_->action_ = 0;
495 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
496 authManager_->authResponseContext_->isShowDialog = false;
497 int32_t ret = authManager_->ConfirmProcessExt(action);
498 ASSERT_EQ(ret, DM_OK);
499 }
500
501 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_002, testing::ext::TestSize.Level1)
502 {
503 int32_t action = 1;
504 authManager_->action_ = 6;
505 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
506 authManager_->authResponseContext_->isShowDialog = true;
507 int32_t ret = authManager_->ConfirmProcessExt(action);
508 ASSERT_EQ(ret, DM_OK);
509 }
510
511 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_003, testing::ext::TestSize.Level1)
512 {
513 int32_t action = 1;
514 authManager_->action_ = 4;
515 int32_t ret = authManager_->ConfirmProcessExt(action);
516 ASSERT_EQ(ret, DM_OK);
517 }
518
519 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_004, testing::ext::TestSize.Level0)
520 {
521 DistributedDeviceProfile::LocalServiceInfo info;
522 info.SetAuthBoxType((int32_t)DMLocalServiceInfoAuthBoxType::SKIP_CONFIRM);
523 info.SetAuthType((int32_t)DMLocalServiceInfoAuthType::TRUST_ONETIME);
524 info.SetPinExchangeType((int32_t)DMLocalServiceInfoPinExchangeType::FROMDP);
525 info.SetPinCode("123456");
526 authManager_->serviceInfoProfile_ = info;
527 ASSERT_TRUE(authManager_->CanUsePincodeFromDp());
528 int32_t action = 1;
529 authManager_->action_ = 6;
530 authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
531 authManager_->authResponseContext_->isShowDialog = true;
532 int32_t ret = authManager_->ConfirmProcessExt(action);
533 ASSERT_EQ(ret, DM_OK);
534 }
535
536 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_001, testing::ext::TestSize.Level0)
537 {
538 authManager_->authResponseContext_ = nullptr;
539 authManager_->StartRespAuthProcess();
540 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
541 }
542
543 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_002, testing::ext::TestSize.Level1)
544 {
545 authManager_->authResponseContext_->groupName = "111111";
546 authManager_->StartRespAuthProcess();
547 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
548 }
549
550 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_003, testing::ext::TestSize.Level1)
551 {
552 authManager_->authResponseContext_->groupName = "00000";
553 authManager_->StartRespAuthProcess();
554 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
555 }
556
557 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_004, testing::ext::TestSize.Level1)
558 {
559 authManager_->authResponseContext_->groupName = "00000";
560 authManager_->authResponseContext_->reply = 0;
561 authManager_->StartRespAuthProcess();
562 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
563 }
564
565 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_005, testing::ext::TestSize.Level1)
566 {
567 authManager_->authResponseContext_->groupName = "11111";
568 authManager_->authResponseContext_->reply = 1;
569 authManager_->StartRespAuthProcess();
570 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
571 }
572
573 HWTEST_F(DmAuthManagerTest, GetConnectAddr_001, testing::ext::TestSize.Level1)
574 {
575 std::string deviceId = "deviceId";
576 auto ret = authManager_->GetConnectAddr(deviceId);
577 ASSERT_EQ(ret.empty(), true);
578 }
579
580 HWTEST_F(DmAuthManagerTest, GetConnectAddr_002, testing::ext::TestSize.Level1)
581 {
582 std::string deviceId = "deviceId";
583 std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
584 infoPtr->addrNum = 1;
585 authManager_->softbusConnector_->discoveryDeviceInfoMap_.insert(
586 std::pair<std::string, std::shared_ptr<DeviceInfo>>(deviceId, infoPtr));
587 auto ret = authManager_->GetConnectAddr(deviceId);
588 ASSERT_EQ(ret.empty(), false);
589 }
590
591 HWTEST_F(DmAuthManagerTest, SinkAuthenticateFinish_001, testing::ext::TestSize.Level1)
592 {
593 authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
594 authManager_->authPtr_ = authManager_->authenticationMap_[1];
595 authManager_->isFinishOfLocal_ = true;
596 authManager_->SinkAuthenticateFinish();
597 ASSERT_EQ(authManager_->authResponseState_, nullptr);
598 }
599
600 HWTEST_F(DmAuthManagerTest, SrcAuthenticateFinish_001, testing::ext::TestSize.Level1)
601 {
602 authManager_->isFinishOfLocal_ = true;
603 authManager_->authResponseContext_->state = 5;
604 authManager_->authPtr_ = authManager_->authenticationMap_[1];
605 authManager_->SrcAuthenticateFinish();
606 usleep(600);
607 ASSERT_EQ(authManager_->authRequestState_, nullptr);
608 }
609
610 HWTEST_F(DmAuthManagerTest, SrcAuthenticateFinish_002, testing::ext::TestSize.Level1)
611 {
612 authManager_->isFinishOfLocal_ = false;
613 authManager_->authResponseContext_->state = 7;
614 authManager_->authPtr_ = authManager_->authenticationMap_[1];
615 authManager_->SrcAuthenticateFinish();
616 usleep(600);
617 ASSERT_EQ(authManager_->authRequestState_, nullptr);
618 }
619
620 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_001, testing::ext::TestSize.Level1)
621 {
622 authManager_->authResponseContext_ = nullptr;
623 authManager_->AuthenticateFinish();
624 ASSERT_EQ(authManager_->authResponseContext_, nullptr);
625 }
626
627 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_002, testing::ext::TestSize.Level1)
628 {
629 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
630 authManager_->authUiStateMgr_ = nullptr;
631 authManager_->AuthenticateFinish();
632 ASSERT_EQ(authManager_->authUiStateMgr_, nullptr);
633 }
634
635 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_003, testing::ext::TestSize.Level1)
636 {
637 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
638 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
639 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
640 authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
641 authManager_->authRequestState_ = nullptr;
642 authManager_->AuthenticateFinish();
643 ASSERT_EQ(authManager_->authResponseContext_, nullptr);
644 }
645
646 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_004, testing::ext::TestSize.Level1)
647 {
648 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
649 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
650 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
651 authManager_->authResponseState_ = nullptr;
652 authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
653 authManager_->AuthenticateFinish();
654 ASSERT_EQ(authManager_->authResponseContext_, nullptr);
655 }
656
657 HWTEST_F(DmAuthManagerTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level1)
658 {
659 std::string pkgName = "ohos_test";
660 authManager_->authUiStateMgr_ = nullptr;
661 int32_t ret = authManager_->RegisterUiStateCallback(pkgName);
662 ASSERT_EQ(ret, ERR_DM_FAILED);
663 }
664
665 HWTEST_F(DmAuthManagerTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level1)
666 {
667 std::string pkgName = "ohos_test";
668 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
669 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
670 int32_t ret = authManager_->RegisterUiStateCallback(pkgName);
671 ASSERT_EQ(ret, DM_OK);
672 }
673
674 HWTEST_F(DmAuthManagerTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level1)
675 {
676 std::string pkgName = "ohos_test";
677 authManager_->authUiStateMgr_ = nullptr;
678 int32_t ret = authManager_->UnRegisterUiStateCallback(pkgName);
679 ASSERT_EQ(ret, ERR_DM_FAILED);
680 }
681
682 HWTEST_F(DmAuthManagerTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level1)
683 {
684 std::string pkgName = "ohos_test";
685 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
686 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
687 int32_t ret = authManager_->UnRegisterUiStateCallback(pkgName);
688 ASSERT_EQ(ret, DM_OK);
689 }
690
691 HWTEST_F(DmAuthManagerTest, SetAuthRequestState_001, testing::ext::TestSize.Level1)
692 {
693 std::shared_ptr<AuthRequestState> authRequestState = nullptr;
694 int32_t ret = authManager_->SetAuthRequestState(authRequestState);
695 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
696 }
697
698 HWTEST_F(DmAuthManagerTest, SetAuthRequestState_002, testing::ext::TestSize.Level1)
699 {
700 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
701 int32_t ret = authManager_->SetAuthRequestState(authRequestState);
702 ASSERT_EQ(ret, DM_OK);
703 }
704
705 HWTEST_F(DmAuthManagerTest, ShowConfigDialog_001, testing::ext::TestSize.Level1)
706 {
707 authManager_->authResponseContext_ = nullptr;
708 authManager_->ShowConfigDialog();
709 ASSERT_EQ(authManager_->authResponseContext_, nullptr);
710 }
711
712 HWTEST_F(DmAuthManagerTest, ShowConfigDialog_002, testing::ext::TestSize.Level1)
713 {
714 authManager_->authResponseContext_->isShowDialog = false;
715 authManager_->ShowConfigDialog();
716 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, false);
717 }
718
719 HWTEST_F(DmAuthManagerTest, ShowConfigDialog_003, testing::ext::TestSize.Level1)
720 {
721 authManager_->authResponseContext_->isShowDialog = true;
722 authManager_->ShowConfigDialog();
723 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, true);
724 }
725
726 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_001, testing::ext::TestSize.Level1)
727 {
728 authManager_->authResponseContext_ = nullptr;
729 authManager_->ShowAuthInfoDialog();
730 ASSERT_EQ(authManager_->authResponseContext_, nullptr);
731 }
732
733 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_002, testing::ext::TestSize.Level1)
734 {
735 authManager_->authResponseContext_->isShowDialog = false;
736 authManager_->ShowAuthInfoDialog();
737 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, false);
738 }
739
740 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_003, testing::ext::TestSize.Level1)
741 {
742 authManager_->authResponseContext_->isShowDialog = true;
743 authManager_->ShowAuthInfoDialog();
744 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, true);
745 }
746
747 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_004, testing::ext::TestSize.Level0)
748 {
749 DistributedDeviceProfile::LocalServiceInfo info;
750 info.SetAuthBoxType((int32_t)DMLocalServiceInfoAuthBoxType::SKIP_CONFIRM);
751 info.SetAuthType((int32_t)DMLocalServiceInfoAuthType::TRUST_ONETIME);
752 info.SetPinExchangeType((int32_t)DMLocalServiceInfoPinExchangeType::FROMDP);
753 info.SetPinCode("123456");
754 authManager_->serviceInfoProfile_ = info;
755 ASSERT_TRUE(authManager_->CanUsePincodeFromDp());
756 authManager_->authResponseContext_->isShowDialog = true;
757 authManager_->ShowAuthInfoDialog();
758 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, true);
759 info.SetPinCode("******");
760 authManager_->serviceInfoProfile_ = info;
761 authManager_->pincodeDialogEverShown_ = true;
762 authManager_->ShowAuthInfoDialog();
763 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, true);
764 authManager_->pincodeDialogEverShown_ = false;
765 authManager_->serviceInfoProfile_ = {};
766 }
767
768 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_001, testing::ext::TestSize.Level0)
769 {
770 authManager_->authResponseContext_ = nullptr;
771 authManager_->ShowStartAuthDialog();
772 ASSERT_EQ(authManager_->authResponseContext_, nullptr);
773 }
774
775 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_002, testing::ext::TestSize.Level1)
776 {
777 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
778 authManager_->importAuthCode_ = "";
779 authManager_->importPkgName_ = "";
780 authManager_->ShowStartAuthDialog();
781 ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, false);
782 }
783
784 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_003, testing::ext::TestSize.Level1)
785 {
786 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
787 authManager_->importAuthCode_ = "123456";
788 authManager_->importPkgName_ = "hostPkgName";
789 authManager_->authResponseContext_->hostPkgName = "hostPkgName";
790 authManager_->authResponseContext_->dmVersion = "dmVersion";
791 authManager_->authResponseContext_->bindLevel = 1;
792 authManager_->ShowStartAuthDialog();
793 ASSERT_EQ(authManager_->authResponseContext_->bindLevel, 1);
794 }
795
796 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_004, testing::ext::TestSize.Level1)
797 {
798 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
799 authManager_->importAuthCode_ = "123456";
800 authManager_->importPkgName_ = "hostPkgName";
801 authManager_->authResponseContext_->hostPkgName = "hostPkgName";
802 authManager_->remoteVersion_ = "4.1.5.2";
803 authManager_->authResponseContext_->bindLevel = USER;
804 authManager_->authResponseContext_->targetDeviceName = "ShowStartAuthDialog_004";
805 authManager_->ShowStartAuthDialog();
806 EXPECT_NE(authManager_->authResponseContext_->targetDeviceName, DmDialogManager::GetInstance().targetDeviceName_);
807
808 authManager_->remoteVersion_ = "4.1.5.2";
809 authManager_->authResponseContext_->bindLevel = APP + 1;
810 authManager_->ShowStartAuthDialog();
811 EXPECT_NE(authManager_->authResponseContext_->targetDeviceName, DmDialogManager::GetInstance().targetDeviceName_);
812
813 authManager_->remoteVersion_ = "4.1.5.2";
814 authManager_->authResponseContext_->bindLevel = INVALIED_TYPE;
815 authManager_->ShowStartAuthDialog();
816 EXPECT_NE(authManager_->authResponseContext_->targetDeviceName, DmDialogManager::GetInstance().targetDeviceName_);
817
818 authManager_->remoteVersion_ = "4.1.5.0";
819 authManager_->ShowStartAuthDialog();
820 EXPECT_NE(authManager_->authResponseContext_->targetDeviceName, DmDialogManager::GetInstance().targetDeviceName_);
821 }
822
823 HWTEST_F(DmAuthManagerTest, ProcessPincode_001, testing::ext::TestSize.Level1)
824 {
825 std::string pinCode = "123456";
826 authManager_->authResponseContext_ = nullptr;
827 int32_t ret = authManager_->ProcessPincode(pinCode);
828 ASSERT_EQ(ret, ERR_DM_FAILED);
829 }
830
831 HWTEST_F(DmAuthManagerTest, ProcessPincode_002, testing::ext::TestSize.Level1)
832 {
833 std::string pinCode = "123456";
834 authManager_->authResponseContext_->dmVersion = "dmVersion";
835 authManager_->authResponseContext_->bindLevel = 1;
836 authManager_->isAuthDevice_ = true;
837 int32_t ret = authManager_->ProcessPincode(pinCode);
838 ASSERT_EQ(ret, ERR_DM_ADD_GROUP_FAILED);
839 }
840
841 HWTEST_F(DmAuthManagerTest, ProcessPincode_003, testing::ext::TestSize.Level1)
842 {
843 std::string pinCode = "";
844 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
845 authManager_->authUiStateMgr_ = nullptr;
846 authManager_->importAuthCode_ = "123456";
847 authManager_->importPkgName_ = "hostPkgName";
848 authManager_->authResponseContext_->hostPkgName = "hostPkgName";
849 authManager_->remoteVersion_ = "4.1.5.2";
850 authManager_->authResponseContext_->bindLevel = USER;
851 authManager_->authResponseContext_->targetDeviceName = "ShowStartAuthDialog_004";
852 EXPECT_CALL(*hiChainAuthConnectorMock_, AuthDevice(_, _, _, _)).WillOnce(Return(DM_OK));
853 int32_t ret = authManager_->ProcessPincode(pinCode);
854 EXPECT_EQ(ret, DM_OK);
855
856 authManager_->remoteVersion_ = "4.1.5.2";
857 authManager_->authResponseContext_->bindLevel = APP + 1;
858 ret = authManager_->ProcessPincode(pinCode);
859 EXPECT_NE(ret, DM_OK);
860
861 authManager_->remoteVersion_ = "4.1.5.2";
862 authManager_->authResponseContext_->bindLevel = INVALIED_TYPE;
863 ret = authManager_->ProcessPincode(pinCode);
864 EXPECT_NE(ret, DM_OK);
865
866 authManager_->remoteVersion_ = "4.1.5.0";
867 ret = authManager_->ProcessPincode(pinCode);
868 EXPECT_NE(ret, DM_OK);
869 }
870
871 HWTEST_F(DmAuthManagerTest, AuthDevice_001, testing::ext::TestSize.Level1)
872 {
873 std::string pinCode = "123456";
874 authManager_->isAuthDevice_ = true;
875 int32_t ret = authManager_->AuthDevice(pinCode);
876 ASSERT_EQ(ret, ERR_DM_FAILED);
877 }
878
879 HWTEST_F(DmAuthManagerTest, AuthDevice_002, testing::ext::TestSize.Level1)
880 {
881 std::string pinCode = "123456";
882 authManager_->isAuthDevice_ = false;
883 authManager_->authResponseContext_->authType = 5;
884 EXPECT_CALL(*hiChainAuthConnectorMock_, AuthDevice(_, _, _, _)).WillOnce(Return(ERR_DM_FAILED));
885 int32_t ret = authManager_->AuthDevice(pinCode);
886 ASSERT_EQ(ret, ERR_DM_FAILED);
887 }
888
889 HWTEST_F(DmAuthManagerTest, ImportAuthCode_001, testing::ext::TestSize.Level1)
890 {
891 std::string authCode = "";
892 std::string pkgName = "pkgName";
893 int32_t ret = authManager_->ImportAuthCode(authCode, pkgName);
894 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
895 }
896
897 HWTEST_F(DmAuthManagerTest, ImportAuthCode_002, testing::ext::TestSize.Level1)
898 {
899 std::string authCode = "123456";
900 std::string pkgName = "";
901 int32_t ret = authManager_->ImportAuthCode(authCode, pkgName);
902 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
903 }
904
905 HWTEST_F(DmAuthManagerTest, ImportAuthCode_003, testing::ext::TestSize.Level1)
906 {
907 std::string authCode = "123456";
908 std::string pkgName = "pkgName";
909 int32_t ret = authManager_->ImportAuthCode(authCode, pkgName);
910 ASSERT_EQ(ret, DM_OK);
911 }
912
913 HWTEST_F(DmAuthManagerTest, BindTarget_001, testing::ext::TestSize.Level1)
914 {
915 std::string pkgName;
916 PeerTargetId targetId;
917 std::map<std::string, std::string> bindParam;
918 int sessionId = 1;
919 int64_t logicalSessionId = 888;
920 int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
921 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
922 }
923
924 HWTEST_F(DmAuthManagerTest, BindTarget_002, testing::ext::TestSize.Level1)
925 {
926 std::string pkgName = "pkgName";
927 PeerTargetId targetId;
928 std::map<std::string, std::string> bindParam;
929 int sessionId = 1;
930 int64_t logicalSessionId = 888;
931 int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
932 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
933 }
934
935 HWTEST_F(DmAuthManagerTest, BindTarget_004, testing::ext::TestSize.Level1)
936 {
937 std::string pkgName = "pkgName";
938 PeerTargetId targetId;
939 targetId.deviceId = "123456";
940 std::map<std::string, std::string> bindParam;
941 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "1"));
942 bindParam.insert(std::pair<std::string, std::string>("CONN_ADDR_TYPE", "3"));
943 int sessionId = 1;
944 int64_t logicalSessionId = 888;
945 int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
946 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
947 }
948
949 HWTEST_F(DmAuthManagerTest, BindTarget_005, testing::ext::TestSize.Level1)
950 {
951 std::string pkgName = "pkgName";
952 PeerTargetId targetId;
953 targetId.deviceId = "";
954 std::map<std::string, std::string> bindParam;
955 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "2"));
956 bindParam.insert(std::pair<std::string, std::string>("CONN_ADDR_TYPE", "3"));
957 int sessionId = 1;
958 int64_t logicalSessionId = 888;
959 int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
960 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
961 }
962
963 HWTEST_F(DmAuthManagerTest, ParseConnectAddr_001, testing::ext::TestSize.Level1)
964 {
965 PeerTargetId targetId;
966 targetId.wifiIp = "12131415";
967 targetId.brMac = "D4G4E5G2B4G";
968 targetId.bleMac = "1463158131321";
969 std::string deviceId;
970 std::string addrType = "123456";
971 int32_t ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
972 ASSERT_EQ(ret, DM_OK);
973 }
974
975 HWTEST_F(DmAuthManagerTest, ParseConnectAddr_002, testing::ext::TestSize.Level1)
976 {
977 PeerTargetId targetId;
978 std::string deviceId;
979 std::string addrType;
980 int32_t ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
981 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
982 }
983
984 HWTEST_F(DmAuthManagerTest, ParseAuthType_001, testing::ext::TestSize.Level1)
985 {
986 int32_t authType = 0;
987 std::map<std::string, std::string> bindParam;
988 int32_t ret = authManager_->ParseAuthType(bindParam, authType);
989 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
990 }
991
992 HWTEST_F(DmAuthManagerTest, ParseAuthType_002, testing::ext::TestSize.Level1)
993 {
994 int32_t authType = 0;
995 std::map<std::string, std::string> bindParam;
996 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", ""));
997 int32_t ret = authManager_->ParseAuthType(bindParam, authType);
998 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
999 }
1000
1001 HWTEST_F(DmAuthManagerTest, ParseAuthType_003, testing::ext::TestSize.Level1)
1002 {
1003 int32_t authType = 0;
1004 std::map<std::string, std::string> bindParam;
1005 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "12"));
1006 int32_t ret = authManager_->ParseAuthType(bindParam, authType);
1007 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1008 }
1009
1010 HWTEST_F(DmAuthManagerTest, ParseAuthType_004, testing::ext::TestSize.Level1)
1011 {
1012 int32_t authType = 0;
1013 std::map<std::string, std::string> bindParam;
1014 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "S"));
1015 int32_t ret = authManager_->ParseAuthType(bindParam, authType);
1016 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1017 }
1018
1019 HWTEST_F(DmAuthManagerTest, ParseAuthType_005, testing::ext::TestSize.Level1)
1020 {
1021 int32_t authType = 0;
1022 std::map<std::string, std::string> bindParam;
1023 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "1"));
1024 int32_t ret = authManager_->ParseAuthType(bindParam, authType);
1025 ASSERT_EQ(ret, DM_OK);
1026 }
1027
1028 HWTEST_F(DmAuthManagerTest, ParseExtraFromMap_001, testing::ext::TestSize.Level1)
1029 {
1030 std::map<std::string, std::string> bindParam;
1031 bindParam.insert(std::pair<std::string, std::string>("BIND_EXTRA_DATA", "12"));
1032 std::string ret = authManager_->ParseExtraFromMap(bindParam);
1033 ASSERT_EQ(ret, "12");
1034 }
1035
1036 HWTEST_F(DmAuthManagerTest, ParseExtraFromMap_002, testing::ext::TestSize.Level1)
1037 {
1038 std::map<std::string, std::string> bindParam;
1039 std::string ret = authManager_->ParseExtraFromMap(bindParam);
1040 ASSERT_EQ(ret, "");
1041 }
1042
1043 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_001, testing::ext::TestSize.Level1)
1044 {
1045 std::string pkgName;
1046 authManager_->importAuthCode_ = "";
1047 authManager_->importPkgName_ = "importPkgName_";
1048 bool ret = authManager_->IsAuthCodeReady(pkgName);
1049 ASSERT_EQ(ret, false);
1050 }
1051
1052 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_002, testing::ext::TestSize.Level1)
1053 {
1054 std::string pkgName;
1055 authManager_->importAuthCode_ = "importAuthCode_";
1056 authManager_->importPkgName_ = "";
1057 bool ret = authManager_->IsAuthCodeReady(pkgName);
1058 ASSERT_EQ(ret, false);
1059 }
1060
1061 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_003, testing::ext::TestSize.Level1)
1062 {
1063 std::string pkgName = "pkgName";
1064 authManager_->importAuthCode_ = "importAuthCode_";
1065 authManager_->importPkgName_ = "importPkgName_";
1066 bool ret = authManager_->IsAuthCodeReady(pkgName);
1067 ASSERT_EQ(ret, false);
1068 }
1069
1070 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_004, testing::ext::TestSize.Level1)
1071 {
1072 std::string pkgName = "ohos_test";
1073 authManager_->importAuthCode_ = "importAuthCode_";
1074 authManager_->importPkgName_ = "ohos_test";
1075 bool ret = authManager_->IsAuthCodeReady(pkgName);
1076 ASSERT_EQ(ret, true);
1077 }
1078
1079 HWTEST_F(DmAuthManagerTest, DeleteAuthCode_001, testing::ext::TestSize.Level1)
1080 {
1081 authManager_->authResponseContext_->authType = 5;
1082 int32_t ret = authManager_->DeleteAuthCode();
1083 ASSERT_EQ(ret, DM_OK);
1084 }
1085
1086 HWTEST_F(DmAuthManagerTest, GetAuthCode_001, testing::ext::TestSize.Level1)
1087 {
1088 std::string pkgName;
1089 std::string pinCode = "1";
1090 authManager_->importAuthCode_ = "";
1091 authManager_->importPkgName_ = "importPkgName_";
1092 int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1093 ASSERT_EQ(ret, ERR_DM_FAILED);
1094 }
1095
1096 HWTEST_F(DmAuthManagerTest, GetAuthCode_002, testing::ext::TestSize.Level1)
1097 {
1098 std::string pkgName;
1099 std::string pinCode = "1";
1100 authManager_->importAuthCode_ = "importAuthCode_";
1101 authManager_->importPkgName_ = "";
1102 int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1103 ASSERT_EQ(ret, ERR_DM_FAILED);
1104 }
1105
1106 HWTEST_F(DmAuthManagerTest, GetAuthCode_003, testing::ext::TestSize.Level1)
1107 {
1108 std::string pkgName = "pkgName";
1109 std::string pinCode = "1";
1110 authManager_->importAuthCode_ = "importAuthCode_";
1111 authManager_->importPkgName_ = "importPkgName_";
1112 int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1113 ASSERT_EQ(ret, ERR_DM_FAILED);
1114 }
1115
1116 HWTEST_F(DmAuthManagerTest, GetAuthCode_004, testing::ext::TestSize.Level1)
1117 {
1118 std::string pkgName = "ohos_test";
1119 std::string pinCode = "1";
1120 authManager_->importAuthCode_ = "123456";
1121 authManager_->importPkgName_ = "ohos_test";
1122 int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1123 ASSERT_EQ(ret, DM_OK);
1124 }
1125
1126 HWTEST_F(DmAuthManagerTest, IsAuthTypeSupported_001, testing::ext::TestSize.Level1)
1127 {
1128 int32_t authType = 7;
1129 bool ret = authManager_->IsAuthTypeSupported(authType);
1130 ASSERT_EQ(ret, false);
1131 }
1132
1133 HWTEST_F(DmAuthManagerTest, IsAuthTypeSupported_002, testing::ext::TestSize.Level1)
1134 {
1135 int32_t authType = 7;
1136 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1137 bool ret = authManager_->IsAuthTypeSupported(authType);
1138 ASSERT_EQ(ret, true);
1139 }
1140
1141 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_001, testing::ext::TestSize.Level1)
1142 {
1143 int32_t authType = -1;
1144 std::string extra;
1145 std::string pkgName = "ohos_test";
1146 std::string deviceId = "512156";
1147 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1148 ASSERT_EQ(ret, ERR_DM_AUTH_FAILED);
1149 }
1150
1151 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_002, testing::ext::TestSize.Level1)
1152 {
1153 int32_t authType = 6;
1154 std::string extra;
1155 std::string pkgName = "ohos_test";
1156 std::string deviceId = "512156";
1157 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1158 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_AUTH_TYPE);
1159 }
1160
1161 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_003, testing::ext::TestSize.Level1)
1162 {
1163 int32_t authType = 4;
1164 std::string extra;
1165 std::string pkgName;
1166 std::string deviceId = "512156";
1167 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1168 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1169 }
1170
1171 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_004, testing::ext::TestSize.Level1)
1172 {
1173 int32_t authType = 4;
1174 std::string extra;
1175 std::string pkgName = "ohos_test";
1176 std::string deviceId;
1177 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1178 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1179 }
1180
1181 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_005, testing::ext::TestSize.Level1)
1182 {
1183 int32_t authType = 4;
1184 std::string extra;
1185 std::string pkgName = "ohos_test";
1186 std::string deviceId = "512156";
1187 authManager_->listener_ = nullptr;
1188 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1189 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1190 }
1191
1192 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_006, testing::ext::TestSize.Level1)
1193 {
1194 int32_t authType = 4;
1195 std::string extra;
1196 std::string pkgName = "ohos_test";
1197 std::string deviceId = "512156";
1198 authManager_->authUiStateMgr_ = nullptr;
1199 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1200 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1201 }
1202
1203 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_007, testing::ext::TestSize.Level1)
1204 {
1205 int32_t authType = 4;
1206 std::string extra;
1207 std::string pkgName = "ohos_test";
1208 std::string deviceId = "512156";
1209 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1210 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1211 authManager_->authenticationMap_.clear();
1212 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1213 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_AUTH_TYPE);
1214 }
1215
1216 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_008, testing::ext::TestSize.Level1)
1217 {
1218 int32_t authType = 4;
1219 std::string extra;
1220 std::string pkgName = "ohos_test";
1221 std::string deviceId = "512156";
1222 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1223 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1224 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1225 authManager_->authRequestState_ = nullptr;
1226 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1227 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1228 }
1229
1230 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_009, testing::ext::TestSize.Level1)
1231 {
1232 int32_t authType = 4;
1233 std::string extra;
1234 std::string pkgName = "ohos_test";
1235 std::string deviceId = "512156";
1236 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1237 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1238 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1239 authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1240 authManager_->authResponseState_ = nullptr;
1241 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1242 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1243 }
1244
1245 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_010, testing::ext::TestSize.Level1)
1246 {
1247 int32_t authType = 4;
1248 std::string extra;
1249 std::string pkgName = "ohos_test";
1250 std::string deviceId = "512156";
1251 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1252 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1253 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1254 authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1255 authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1256 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1257 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1258 }
1259
1260 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0011, testing::ext::TestSize.Level1)
1261 {
1262 int32_t authType = 4;
1263 std::string extra;
1264 std::string pkgName = "ohos_test";
1265 std::string deviceId = "512156";
1266 authManager_->importPkgName_ = "ohos_test";
1267 authManager_->importAuthCode_ = "156161";
1268 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1269 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1270 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1271 authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1272 authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1273 authManager_->softbusConnector_->discoveryDeviceInfoMap_.clear();
1274 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1275 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1276 }
1277
1278 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0012, testing::ext::TestSize.Level1)
1279 {
1280 int32_t authType = 5;
1281 std::string extra;
1282 std::string pkgName = "ohos_test";
1283 std::string deviceId = "512156";
1284 authManager_->importPkgName_ = "";
1285 authManager_->importAuthCode_ = "";
1286 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1287 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1288 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1289 std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
1290 authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
1291 authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1292 authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1293 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1294 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1295 }
1296
1297 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0013, testing::ext::TestSize.Level1)
1298 {
1299 int32_t authType = 5;
1300 std::string extra;
1301 std::string pkgName = "ohos_test";
1302 std::string deviceId = "512156";
1303 authManager_->importPkgName_ = "ohos_test";
1304 authManager_->importAuthCode_ = "156161";
1305 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1306 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1307 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1308 authManager_->authRequestState_ = nullptr;
1309 authManager_->authResponseState_ = nullptr;
1310 authManager_->softbusConnector_->discoveryDeviceInfoMap_.clear();
1311 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1312 ASSERT_EQ(ret, DM_OK);
1313 }
1314
1315 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0014, testing::ext::TestSize.Level1)
1316 {
1317 int32_t authType = 4;
1318 std::string extra;
1319 std::string pkgName = "ohos_test";
1320 std::string deviceId = "512156";
1321 authManager_->importAuthCode_ = "";
1322 authManager_->importAuthCode_ = "";
1323 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1324 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1325 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1326 std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
1327 authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
1328 authManager_->authRequestState_ = nullptr;
1329 authManager_->authResponseState_ = nullptr;
1330 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1331 ASSERT_EQ(ret, DM_OK);
1332 }
1333
1334 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0015, testing::ext::TestSize.Level1)
1335 {
1336 int32_t authType = 5;
1337 std::string extra;
1338 std::string pkgName = "ohos_test";
1339 std::string deviceId = "512156";
1340 authManager_->importAuthCode_ = "";
1341 authManager_->importAuthCode_ = "";
1342 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1343 authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1344 authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1345 std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
1346 authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
1347 authManager_->authRequestState_ = nullptr;
1348 authManager_->authResponseState_ = nullptr;
1349 int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1350 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1351 }
1352
1353 HWTEST_F(DmAuthManagerTest, StartNegotiate_001, testing::ext::TestSize.Level1)
1354 {
1355 int32_t sessionId = 123;
1356 authManager_->authMessageProcessor_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1357 authManager_->StartNegotiate(sessionId);
1358 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1359 }
1360
1361 HWTEST_F(DmAuthManagerTest, StartNegotiate_002, testing::ext::TestSize.Level1)
1362 {
1363 int32_t sessionId = 123;
1364 authManager_->authResponseContext_ = nullptr;
1365 authManager_->StartNegotiate(sessionId);
1366 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1367 }
1368
1369 HWTEST_F(DmAuthManagerTest, GetAuthParam_001, testing::ext::TestSize.Level1)
1370 {
1371 int32_t authType = 5;
1372 std::string extra;
1373 std::string pkgName = "ohos_test";
1374 std::string deviceId = "512156";
1375 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1376 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1377 }
1378
1379 HWTEST_F(DmAuthManagerTest, GetAuthParam_002, testing::ext::TestSize.Level1)
1380 {
1381 JsonObject jsonObject;
1382 jsonObject["targetPkgName"] = 1234;
1383 std::string extra = jsonObject.Dump();
1384 int32_t authType = 5;
1385 std::string pkgName = "ohos_test";
1386 std::string deviceId = "512156";
1387 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1388 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1389 }
1390
1391 HWTEST_F(DmAuthManagerTest, GetAuthParam_003, testing::ext::TestSize.Level1)
1392 {
1393 JsonObject jsonObject;
1394 jsonObject["targetPkgName"] = "1234";
1395 jsonObject["appOperation"] = 1234;
1396 std::string extra = jsonObject.Dump();
1397 int32_t authType = 5;
1398 std::string pkgName = "ohos_test";
1399 std::string deviceId = "512156";
1400 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1401 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1402 }
1403
1404 HWTEST_F(DmAuthManagerTest, GetAuthParam_004, testing::ext::TestSize.Level1)
1405 {
1406 JsonObject jsonObject;
1407 jsonObject["targetPkgName"] = "1234";
1408 jsonObject["appOperation"] = "1234";
1409 jsonObject["customDescription"] = 1234;
1410 std::string extra = jsonObject.Dump();
1411 int32_t authType = 5;
1412 std::string pkgName = "ohos_test";
1413 std::string deviceId = "512156";
1414 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1415 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1416 }
1417
1418 HWTEST_F(DmAuthManagerTest, GetAuthParam_005, testing::ext::TestSize.Level1)
1419 {
1420 JsonObject jsonObject;
1421 jsonObject["targetPkgName"] = "1234";
1422 jsonObject["appOperation"] = "1234";
1423 jsonObject["customDescription"] = "1234";
1424 jsonObject["appThumbnail"] = 1234;
1425 std::string extra = jsonObject.Dump();
1426 int32_t authType = 5;
1427 std::string pkgName = "ohos_test";
1428 std::string deviceId = "512156";
1429 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1430 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1431 }
1432
1433 HWTEST_F(DmAuthManagerTest, GetAuthParam_006, testing::ext::TestSize.Level1)
1434 {
1435 JsonObject jsonObject;
1436 jsonObject["targetPkgName"] = "1234";
1437 jsonObject["appOperation"] = "1234";
1438 jsonObject["customDescription"] = "1234";
1439 jsonObject["appThumbnail"] = "1234";
1440 jsonObject["tokenId"] = "1234";
1441 std::string extra = jsonObject.Dump();
1442 int32_t authType = 5;
1443 std::string pkgName = "ohos_test";
1444 std::string deviceId = "512156";
1445 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1446 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1447 }
1448
1449 HWTEST_F(DmAuthManagerTest, GetAuthParam_007, testing::ext::TestSize.Level1)
1450 {
1451 JsonObject jsonObject;
1452 jsonObject["targetPkgName"] = "1234";
1453 jsonObject["appOperation"] = "1234";
1454 jsonObject["customDescription"] = "1234";
1455 jsonObject["appThumbnail"] = "1234";
1456 jsonObject["tokenId"] = 1234;
1457 jsonObject["bindLevel"] = "1234";
1458 std::string extra = jsonObject.Dump();
1459 int32_t authType = 5;
1460 std::string pkgName = "ohos_test";
1461 std::string deviceId = "512156";
1462 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1463 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1464 }
1465
1466 HWTEST_F(DmAuthManagerTest, GetAuthParam_008, testing::ext::TestSize.Level1)
1467 {
1468 JsonObject jsonObject;
1469 jsonObject["targetPkgName"] = "1234";
1470 jsonObject["appOperation"] = "1234";
1471 jsonObject["customDescription"] = "1234";
1472 jsonObject["appThumbnail"] = "1234";
1473 jsonObject["tokenId"] = 1234;
1474 jsonObject["bindLevel"] = 1234;
1475 std::string extra = jsonObject.Dump();
1476 int32_t authType = 5;
1477 std::string pkgName = "ohos_test";
1478 std::string deviceId = "512156";
1479 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1480 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1481 }
1482
1483 HWTEST_F(DmAuthManagerTest, GetAuthParam_009, testing::ext::TestSize.Level1)
1484 {
1485 JsonObject jsonObject;
1486 jsonObject["DM_CLOSE_SESSION_DELAY_SECONDS"] = 1234;
1487 std::string extra = jsonObject.Dump();
1488 int32_t authType = 5;
1489 std::string pkgName = "ohos_test";
1490 std::string deviceId = "512156";
1491 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1492 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1493 }
1494
1495 HWTEST_F(DmAuthManagerTest, GetAuthParam_010, testing::ext::TestSize.Level1)
1496 {
1497 JsonObject jsonObject;
1498 jsonObject["DM_CLOSE_SESSION_DELAY_SECONDS"] = "1234";
1499 std::string extra = jsonObject.Dump();
1500 int32_t authType = 5;
1501 std::string pkgName = "ohos_test";
1502 std::string deviceId = "512156";
1503 authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1504 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1505 }
1506
1507 HWTEST_F(DmAuthManagerTest, InitAuthState_001, testing::ext::TestSize.Level1)
1508 {
1509 std::string extra;
1510 int32_t authType = 5;
1511 std::string pkgName = "ohos_test";
1512 std::string deviceId = "512156";
1513 authManager_->timer_ = nullptr;
1514 authManager_->InitAuthState(pkgName, authType, deviceId, extra);
1515 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1516 authManager_->timer_ = std::make_shared<DmTimer>();
1517 authManager_->InitAuthState(pkgName, authType, deviceId, extra);
1518 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1519 }
1520
1521 HWTEST_F(DmAuthManagerTest, HandleSessionHeartbeat_001, testing::ext::TestSize.Level1)
1522 {
1523 std::string name;
1524 authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1525 authManager_->HandleSessionHeartbeat(name);
1526 ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1527 }
1528
1529 HWTEST_F(DmAuthManagerTest, CheckTrustState_001, testing::ext::TestSize.Level1)
1530 {
1531 authManager_->authResponseContext_->isOnline = true;
1532 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
1533 authManager_->importAuthCode_ = "test";
1534 authManager_->authResponseContext_->importAuthCode = Crypto::Sha256(authManager_->importAuthCode_);
1535 int32_t ret = authManager_->CheckTrustState();
1536 ASSERT_NE(ret, DM_OK);
1537 }
1538
1539 HWTEST_F(DmAuthManagerTest, CheckTrustState_002, testing::ext::TestSize.Level1)
1540 {
1541 authManager_->authResponseContext_->isOnline = true;
1542 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
1543 authManager_->importAuthCode_ = "test";
1544 authManager_->authResponseContext_->importAuthCode = "test";
1545 int32_t ret = authManager_->CheckTrustState();
1546 ASSERT_NE(ret, DM_OK);
1547 }
1548
1549 HWTEST_F(DmAuthManagerTest, IsIdenticalAccount_201, testing::ext::TestSize.Level1)
1550 {
1551 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(-1));
1552 bool ret = authManager_->IsIdenticalAccount();
1553 ASSERT_FALSE(ret);
1554
1555 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1556 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(false));
1557 ret = authManager_->IsIdenticalAccount();
1558 ASSERT_FALSE(ret);
1559
1560 authManager_->authResponseContext_ = nullptr;
1561 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1562 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(true));
1563 ret = authManager_->IsIdenticalAccount();
1564 ASSERT_FALSE(ret);
1565
1566 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1567 authManager_->authResponseContext_->accountGroupIdHash = OLD_VERSION_ACCOUNT;
1568 EXPECT_CALL(*multipleUserConnectorMock_,
1569 GetCurrentAccountUserID()).Times(::testing::AtLeast(5)).WillRepeatedly(Return(0));
1570 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(true));
1571 ret = authManager_->IsIdenticalAccount();
1572 ASSERT_TRUE(ret);
1573
1574 EXPECT_CALL(*hiChainConnectorMock_, IsDevicesInP2PGroup(_, _)).WillOnce(Return(true));
1575 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
1576 authManager_->importAuthCode_= "importAuthCode";
1577 authManager_->importPkgName_ = "importPkgName";
1578 authManager_->authResponseContext_->hostPkgName = "importPkgName";
1579 authManager_->AbilityNegotiate();
1580
1581 EXPECT_CALL(*hiChainConnectorMock_, IsDevicesInP2PGroup(_, _)).WillOnce(Return(true));
1582 authManager_->importAuthCode_= "";
1583 authManager_->authResponseContext_->authType = AUTH_TYPE_NFC;
1584 authManager_->AbilityNegotiate();
1585
1586 authManager_->authResponseContext_->isOnline = true;
1587 EXPECT_CALL(*softbusConnectorMock_, CheckIsOnline(_)).WillOnce(Return(true));
1588 EXPECT_CALL(*hiChainAuthConnectorMock_, QueryCredential(_, _, _)).WillOnce(Return(true));
1589 authManager_->GetAuthRequestContext();
1590
1591 JsonObject jsonPeerGroupIdObj;
1592 jsonPeerGroupIdObj["groupId"] = "123456";
1593 authManager_->authResponseContext_->accountGroupIdHash = jsonPeerGroupIdObj.Dump();
1594 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1595 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(true));
1596 EXPECT_CALL(*cryptoMock_, GetGroupIdHash(_)).WillOnce(Return("123"));
1597 ret = authManager_->IsIdenticalAccount();
1598 ASSERT_FALSE(ret);
1599 }
1600
1601 HWTEST_F(DmAuthManagerTest, GetAccountGroupIdHash_201, testing::ext::TestSize.Level1)
1602 {
1603 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(-1));
1604 auto ret = authManager_->GetAccountGroupIdHash();
1605 ASSERT_TRUE(ret.empty());
1606
1607 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1608 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(true));
1609 ret = authManager_->GetAccountGroupIdHash();
1610 ASSERT_FALSE(ret.empty());
1611
1612 std::vector<GroupInfo> groupList;
1613 GroupInfo groupInfo;
1614 groupInfo.groupId = "123456";
1615 groupInfo.groupName = "group101";
1616 groupInfo.groupType = 1;
1617 groupList.push_back(groupInfo);
1618 JsonObject jsonPeerGroupIdObj;
1619 jsonPeerGroupIdObj["groupId"] = "123456";
1620 authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1621 authManager_->authResponseContext_->accountGroupIdHash = jsonPeerGroupIdObj.Dump();
1622 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1623 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _))
1624 .WillOnce(DoAll(SetArgReferee<2>(groupList), Return(true)));
1625 EXPECT_CALL(*cryptoMock_, GetGroupIdHash(_)).WillOnce(Return("123456"));
1626 bool rets = authManager_->IsIdenticalAccount();
1627 ASSERT_FALSE(rets);
1628
1629 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1630 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _))
1631 .WillOnce(DoAll(SetArgReferee<2>(groupList), Return(true)));
1632 ret = authManager_->GetAccountGroupIdHash();
1633 ASSERT_FALSE(ret.empty());
1634 }
1635
1636 HWTEST_F(DmAuthManagerTest, CheckTrustState_003, testing::ext::TestSize.Level1)
1637 {
1638 authManager_->authResponseContext_->reply = ERR_DM_AUTH_BUSINESS_BUSY;
1639 authManager_->authResponseContext_->isIdenticalAccount = true;
1640 authManager_->authResponseContext_->accountGroupIdHash = OLD_VERSION_ACCOUNT;
1641 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1642 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(true));
1643 int32_t ret = authManager_->CheckTrustState();
1644 ASSERT_EQ(ret, 1);
1645
1646 int32_t sessionId = 1;
1647 authManager_->authResponseContext_->authType = AUTH_TYPE_PIN;
1648 authManager_->authResponseContext_->isOnline = true;
1649 EXPECT_CALL(*softbusConnectorMock_, CheckIsOnline(_)).Times(::testing::AtLeast(2)).WillOnce(Return(true));
1650 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1651 EXPECT_CALL(*hiChainConnectorMock_, GetGroupInfo(_, _, _)).WillOnce(Return(true));
1652 authManager_->ProcessAuthRequest(sessionId);
1653
1654 authManager_->authResponseContext_->haveCredential = true;
1655 EXPECT_CALL(*hiChainAuthConnectorMock_,
1656 QueryCredential(_, _, _)).Times(::testing::AtLeast(2)).WillOnce(Return(true));
1657 authManager_->GetAuthRequestContext();
1658
1659 authManager_->authResponseContext_->isOnline = true;
1660 authManager_->authResponseContext_->authType = AUTH_TYPE_IMPORT_AUTH_CODE;
1661 authManager_->authResponseContext_->importAuthCode = "";
1662 authManager_->importAuthCode_ = "";
1663 std::vector<int32_t> bindType;
1664 bindType.push_back(101);
1665 bindType.push_back(102);
1666 EXPECT_CALL(*softbusConnectorMock_, CheckIsOnline(_)).Times(::testing::AtLeast(1)).WillOnce(Return(true));
1667 EXPECT_CALL(*deviceProfileConnectorMock_, SyncAclByBindType(_, _, _, _)).WillOnce(Return(bindType));
1668 authManager_->ProcessAuthRequestExt(sessionId);
1669 }
1670
1671 HWTEST_F(DmAuthManagerTest, DeleteGroup_201, testing::ext::TestSize.Level1)
1672 {
1673 std::string pkgName = "pkgName";
1674 std::string deviceId;
1675 std::vector<GroupInfo> groupList;
1676 GroupInfo groupInfo;
1677 groupInfo.groupId = "123456";
1678 groupList.push_back(groupInfo);
1679 EXPECT_CALL(*hiChainConnectorMock_, GetRelatedGroups(_, _))
1680 .WillOnce(DoAll(SetArgReferee<1>(groupList), Return(DM_OK)));
1681 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).WillOnce(Return(0));
1682 int32_t ret = authManager_->DeleteGroup(pkgName, deviceId);
1683 ASSERT_EQ(ret, DM_OK);
1684 }
1685
1686 HWTEST_F(DmAuthManagerTest, DeleteGroup_202, testing::ext::TestSize.Level1)
1687 {
1688 std::string pkgName;
1689 int32_t userId = 0;
1690 std::string deviceId;
1691 int32_t ret = authManager_->DeleteGroup(pkgName, userId, deviceId);
1692 ASSERT_EQ(ret, ERR_DM_FAILED);
1693
1694 pkgName = "pkgName";
1695 std::vector<GroupInfo> groupList;
1696 GroupInfo groupInfo;
1697 groupInfo.groupId = "123456";
1698 groupList.push_back(groupInfo);
1699 GroupInfo groupInfo1;
1700 groupInfo1.groupId = "12345";
1701 groupList.push_back(groupInfo1);
1702 EXPECT_CALL(*hiChainConnectorMock_, GetRelatedGroups(_, _, _))
1703 .WillOnce(DoAll(SetArgReferee<2>(groupList), Return(DM_OK)));
1704 ret = authManager_->DeleteGroup(pkgName, userId, deviceId);
1705 ASSERT_EQ(ret, DM_OK);
1706 }
1707
1708 HWTEST_F(DmAuthManagerTest, ParseConnectAddr_201, testing::ext::TestSize.Level1)
1709 {
1710 PeerTargetId targetId;
1711 targetId.wifiIp = "12131415";
1712 targetId.brMac = "D4G4E5G2B4G";
1713 targetId.bleMac = "1463158131321";
1714 std::string deviceId;
1715 std::string addrType;
1716 int32_t ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
1717 ASSERT_EQ(ret, DM_OK);
1718 }
1719
1720 HWTEST_F(DmAuthManagerTest, ParseConnectAddr_202, testing::ext::TestSize.Level1)
1721 {
1722 PeerTargetId targetId;
1723 targetId.wifiIp;
1724 targetId.brMac = "D4G4E5G2B4G";
1725 targetId.bleMac = "1463158131321";
1726 std::string deviceId;
1727 std::string addrType;
1728 targetId.deviceId = "dsklalsk556";
1729 int32_t ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
1730 ASSERT_EQ(ret, DM_OK);
1731
1732 targetId.brMac = "";
1733 ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
1734 ASSERT_EQ(ret, DM_OK);
1735 }
1736
1737 HWTEST_F(DmAuthManagerTest, BindTarget_006, testing::ext::TestSize.Level1)
1738 {
1739 std::string pkgName = "pkgName";
1740 PeerTargetId targetId;
1741 targetId.brMac = "D4G4E5G24D5S";
1742 targetId.bleMac = "1463158131321";
1743 targetId.deviceId = "";
1744 std::map<std::string, std::string> bindParam;
1745 bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "2"));
1746 bindParam.insert(std::pair<std::string, std::string>("CONN_ADDR_TYPE", "3"));
1747 int sessionId = 1;
1748 int64_t logicalSessionId = 888;
1749 int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
1750 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_AUTH_TYPE);
1751 }
1752 } // namespace
1753 } // namespace DistributedHardware
1754 } // namespace OHOS
1755