1 /*
2 * Copyright (c) 2022-2023 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.h"
17
18 #include "nlohmann/json.hpp"
19
20 #include "dm_log.h"
21 #include "dm_constants.h"
22 #include "dm_auth_manager.h"
23 #include "auth_message_processor.h"
24 #include "device_manager_service_listener.h"
25
26 namespace OHOS {
27 namespace DistributedHardware {
SetUp()28 void DmAuthManagerTest::SetUp()
29 {
30 }
TearDown()31 void DmAuthManagerTest::TearDown()
32 {
33 }
SetUpTestCase()34 void DmAuthManagerTest::SetUpTestCase()
35 {
36 }
TearDownTestCase()37 void DmAuthManagerTest::TearDownTestCase()
38 {
39 }
40
41 namespace {
42 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
43 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
44 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
45 const int32_t MIN_PIN_CODE = 100000;
46 const int32_t MAX_PIN_CODE = 999999;
47 /**
48 * @tc.name: DmAuthManager::UnAuthenticateDevice_001
49 * @tc.desc: Call unauthenticateddevice to check whether the return value is DM_ FAILED
50 * @tc.type: FUNC
51 * @tc.require: AR000GHSJK
52 */
53 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
54 {
55 std::shared_ptr<DmAuthManager> authManager =
56 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
57 std::shared_ptr<SoftbusSession> sessionSession = std::shared_ptr<SoftbusSession>();
58 std::shared_ptr<DmAuthRequestContext> authRequestContext = std::make_shared<DmAuthRequestContext>();
59 std::string pkgName = "";
60 std::string deviceId = "222";
61 int32_t ret = authManager->UnAuthenticateDevice(pkgName, deviceId);
62 ASSERT_EQ(ret, ERR_DM_FAILED);
63 }
64
65 /**
66 * @tc.name: DmAuthManager::HandleAuthenticateTimeout_001
67 * @tc.desc: authResponseContext_= nullptr; Call handleauthenticatemeout to check whether return value is ERR_DM_FAILED
68 * @tc.type: FUNC
69 * @tc.require: AR000GHSJK
70 */
71 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_001, testing::ext::TestSize.Level0)
72 {
73 std::string name = "test";
74 std::shared_ptr<DmAuthManager> authManager =
75 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
76 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
77 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
78 authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
79 authManager->authResponseContext_ = nullptr;
80 authManager->SetAuthRequestState(authRequestState);
81 authManager->HandleAuthenticateTimeout(name);
82 ASSERT_TRUE(authManager->authResponseContext_ != nullptr);
83 }
84
85 /**
86 * @tc.name: DmAuthManager::HandleAuthenticateTimeout_002
87 * @tc.desc: authResponseContext_= nullptr; Call handleauthenticatemeout to check whether the return value is DM_OK
88 * @tc.type: FUNC
89 * @tc.require: AR000GHSJK
90 */
91 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_002, testing::ext::TestSize.Level0)
92 {
93 std::string name = "test";
94 std::shared_ptr<DmAuthManager> authManager =
95 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
96 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
97 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
98 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
99 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
100 authManager->SetAuthRequestState(authRequestState);
101 authManager->HandleAuthenticateTimeout(name);
102 ASSERT_TRUE(authManager->authRequestState_ != nullptr);
103 }
104
105 /**
106 * @tc.name: DmAuthManager::EstablishAuthChannel_001
107 * @tc.desc: Call establishauthchannel to check whether the return value is DM_ FAILED
108 * @tc.type: FUNC
109 * @tc.require: AR000GHSJK
110 */
111 HWTEST_F(DmAuthManagerTest, EstablishAuthChannel_001, testing::ext::TestSize.Level0)
112 {
113 std::shared_ptr<DmAuthManager> authManager =
114 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
115 std::shared_ptr<SoftbusSession> sessionSession = std::shared_ptr<SoftbusSession>();
116 std::shared_ptr<DmAuthResponseContext> authRequestContext = std::make_shared<DmAuthResponseContext>();
117 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
118 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
119 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
120 std::string deviceId1;
121 int32_t ret = authManager->EstablishAuthChannel(deviceId1);
122 ASSERT_EQ(ret, DM_OK);
123 }
124
125 /**
126 * @tc.name: DmAuthManager::StartAuthProcess_001
127 * @tc.desc: Whether the return value of calling startauthprocess is ERR_DM_FAILED
128 * @tc.type: FUNC
129 * @tc.require: AR000GHSJK
130 */
131 HWTEST_F(DmAuthManagerTest, StartAuthProcess_001, testing::ext::TestSize.Level0)
132 {
133 std::shared_ptr<DmAuthManager> authManager =
134 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
135 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
136 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
137 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
138 authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
139 authManager->SetAuthResponseState(authResponseState);
140 int32_t action = 0;
141 authManager->StartAuthProcess(action);
142 bool ret = authManager->authRequestContext_->deviceName.empty();
143 ASSERT_EQ(ret, true);
144 }
145
146 /**
147 * @tc.name: DmAuthManager::StartAuthProcess_002
148 * @tc.desc: Whether the return value of calling startauthprocess is DM_ OK
149 * @tc.type: FUNC
150 * @tc.require: AR000GHSJK
151 */
152 HWTEST_F(DmAuthManagerTest, StartAuthProcess_002, testing::ext::TestSize.Level0)
153 {
154 std::shared_ptr<DmAuthManager> authManager =
155 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
156 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
157 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
158 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
159 authManager->authResponseState_ = std::make_shared<AuthResponseInitState>();
160 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
161 authManager->SetAuthResponseState(authResponseState);
162 authManager->authResponseContext_->sessionId = 111;
163 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
164 int32_t action = 1;
165 int32_t ret = authManager->StartAuthProcess(action);
166 ASSERT_EQ(ret, DM_OK);
167 }
168
169 /**
170 * @tc.name: DmAuthManager::StartAuthProcess_003
171 * @tc.desc: Set authResponseContext_ is nullptr return ERR_DM_AUTH_NOT_START
172 * @tc.type: FUNC
173 * @tc.require: AR000GHSJK
174 */
175 HWTEST_F(DmAuthManagerTest, StartAuthProcess_003, testing::ext::TestSize.Level0)
176 {
177 std::shared_ptr<DmAuthManager> authManager =
178 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
179 authManager->authResponseContext_ = nullptr;
180 int32_t action = 1;
181 int32_t ret = authManager->StartAuthProcess(action);
182 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
183 }
184
185 /**
186 * @tc.name: DmAuthManager::CreateGroup_001
187 * @tc.desc: Whether the return value of calling creategroup is DM_ OK
188 * @tc.type: FUNC
189 * @tc.require: AR000GHSJK
190 */
191 HWTEST_F(DmAuthManagerTest, CreateGroup_001, testing::ext::TestSize.Level0)
192 {
193 std::shared_ptr<DmAuthManager> authManager =
194 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
195 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
196 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
197 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
198 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
199 authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
200 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
201 authManager->SetAuthResponseState(authResponseState);
202 authManager->authResponseContext_->requestId = 111;
203 authManager->authResponseContext_->groupName = "111";
204 int32_t ret = authManager->CreateGroup();
205 ASSERT_EQ(ret, DM_OK);
206 }
207
208 /**
209 * @tc.name: DmAuthManager::CreateGroup_002
210 * @tc.desc: Whether the return value of calling creategroup is ERR_DM_FAILED
211 * @tc.type: FUNC
212 * @tc.require: AR000GHSJK
213 */
214 HWTEST_F(DmAuthManagerTest, CreateGroup_002, testing::ext::TestSize.Level0)
215 {
216 std::shared_ptr<DmAuthManager> authManager =
217 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
218 authManager->authResponseContext_ = nullptr;
219 int32_t ret = authManager->CreateGroup();
220 ASSERT_EQ(ret, ERR_DM_FAILED);
221 }
222
223 /**
224 * @tc.name: DmAuthManager::AddMember_001
225 * @tc.desc: Whether the return value of calling addmember is DM_ OK
226 * @tc.type: FUNC
227 * @tc.require: AR000GHSJK
228 */
229 HWTEST_F(DmAuthManagerTest, AddMember_001, testing::ext::TestSize.Level0)
230 {
231 std::shared_ptr<DmAuthManager> authManager =
232 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
233 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
234 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
235 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
236 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
237 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
238 nlohmann::json jsonObject;
239 authManager->authResponseContext_->groupId = "111";
240 authManager->authResponseContext_->groupName = "222";
241 authManager->authResponseContext_->code = 123;
242 authManager->authResponseContext_->requestId = 234;
243 authManager->authResponseContext_->deviceId = "234";
244 int32_t pinCode = 444444;
245 authManager->timer_ = std::make_shared<DmTimer>();
246 authManager->hiChainConnector_->RegisterHiChainCallback(authManager);
247 authManager->SetAuthResponseState(authResponseState);
248 int32_t ret = authManager->AddMember(pinCode);
249 ASSERT_NE(ret, -1);
250 }
251
252 /**
253 * @tc.name: DmAuthManager::AddMember_002
254 * @tc.desc: Whether the return value of calling AddMember is ERR_DM_FAILED
255 * @tc.type: FUNC
256 * @tc.require: AR000GHSJK
257 */
258 HWTEST_F(DmAuthManagerTest, AddMember_002, testing::ext::TestSize.Level0)
259 {
260 std::shared_ptr<DmAuthManager> authManager =
261 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
262 int32_t pinCode = 33333;
263 authManager->authResponseContext_ = nullptr;
264 int32_t ret = authManager->AddMember(pinCode);
265 ASSERT_EQ(ret, ERR_DM_FAILED);
266 }
267
268 /**
269 * @tc.name: DmAuthManager::JoinNetwork_001
270 * @tc.desc: Whether the return value of calling joinnetwork is DM_OK
271 * @tc.type: FUNC
272 * @tc.require: AR000GHSJK
273 */
274 HWTEST_F(DmAuthManagerTest, JoinNetwork_001, testing::ext::TestSize.Level0)
275 {
276 std::shared_ptr<DmAuthManager> authManager =
277 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
278 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
279 authManager->timer_ = std::make_shared<DmTimer>();
280 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
281 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
282 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
283 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
284 const int32_t sessionId = 65;
285 const std::string message = "messageTest";
286 int64_t requestId = 444;
287 const std::string groupId = "{}";
288 int32_t status = 1;
289 authManager->OnGroupCreated(requestId, groupId);
290 authManager->OnMemberJoin(requestId, status);
291 authManager->OnDataReceived(sessionId, message);
292 authManager->SetAuthRequestState(authRequestState);
293 int32_t ret = authManager->JoinNetwork();
294 ASSERT_EQ(ret, DM_OK);
295 }
296
297 /**
298 * @tc.name: DmAuthManager::JoinNetwork_002
299 * @tc.desc: Whether the return value of calling joinnetwork is ERR_DM_FAILED
300 * @tc.type: FUNC
301 * @tc.require: AR000GHSJK
302 */
303 HWTEST_F(DmAuthManagerTest, JoinNetwork_002, testing::ext::TestSize.Level0)
304 {
305 std::shared_ptr<DmAuthManager> authManager =
306 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
307 authManager->authResponseContext_ = nullptr;
308 int32_t userId = 1;
309 authManager->UserSwitchEventCallback(userId);
310 authManager->AuthenticateFinish();
311 authManager->CancelDisplay();
312 int32_t ret = authManager->JoinNetwork();
313 ASSERT_EQ(ret, ERR_DM_FAILED);
314 }
315
316 /**
317 * @tc.name: DmAuthManager::SetAuthResponseState_001
318 * @tc.desc: Is the authresponsestate assignment successful
319 * @tc.type: FUNC
320 * @tc.require: AR000GHSJK
321 */
322 HWTEST_F(DmAuthManagerTest, SetAuthResponseState_001, testing::ext::TestSize.Level0)
323 {
324 std::shared_ptr<DmAuthManager> authManager =
325 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
326 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
327 authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
328 authManager->SetAuthResponseState(authResponseState);
329 int32_t ret = authManager->SetAuthResponseState(authResponseState);
330 ASSERT_EQ(ret, DM_OK);
331 }
332
333 /**
334 * @tc.name: DmAuthManager::GetPinCode_001
335 * @tc.desc: Return authresponsecontext - > code
336 * @tc.type: FUNC
337 * @tc.require: AR000GHSJK
338 */
339 HWTEST_F(DmAuthManagerTest, GetPinCode_001, testing::ext::TestSize.Level0)
340 {
341 std::shared_ptr<DmAuthManager> authManager =
342 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
343 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
344 authManager->authResponseContext_->code = 123456;
345 int32_t ret = authManager->GetPinCode();
346 ASSERT_EQ(ret, 123456);
347 }
348
349 /**
350 * @tc.name: DmAuthManager::GetPinCode_002
351 * @tc.desc: Set authResponseContext_ is nullptr Return ERR_DM_AUTH_NOT_START
352 * @tc.type: FUNC
353 * @tc.require: AR000GHSJK
354 */
355 HWTEST_F(DmAuthManagerTest, GetPinCode_002, testing::ext::TestSize.Level0)
356 {
357 std::shared_ptr<DmAuthManager> authManager =
358 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
359 authManager->authResponseContext_ = nullptr;
360 authManager->ShowConfigDialog();
361 authManager->ShowAuthInfoDialog();
362 authManager->ShowStartAuthDialog();
363 int32_t ret = authManager->GetPinCode();
364 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
365 }
366
367 /**
368 * @tc.name: DmAuthManager::SetPageId_001
369 * @tc.desc: Return DM_OK
370 * @tc.type: FUNC
371 * @tc.require: AR000GHSJK
372 */
373 HWTEST_F(DmAuthManagerTest, SetPageId_001, testing::ext::TestSize.Level0)
374 {
375 std::shared_ptr<DmAuthManager> authManager =
376 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
377 int32_t pageId = 123;
378 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
379 int32_t ret = authManager->SetPageId(pageId);
380 ASSERT_EQ(ret, DM_OK);
381 }
382
383 /**
384 * @tc.name: DmAuthManager::SetPageId_002
385 * @tc.desc: Return ERR_DM_AUTH_NOT_START
386 * @tc.type: FUNC
387 * @tc.require: AR000GHSJK
388 */
389 HWTEST_F(DmAuthManagerTest, SetPageId_002, testing::ext::TestSize.Level0)
390 {
391 std::shared_ptr<DmAuthManager> authManager =
392 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
393 int32_t pageId = 123;
394 authManager->authResponseContext_ = nullptr;
395 authManager->authMessageProcessor_ = nullptr;
396 const int32_t sessionId = 65;
397 const std::string message = "messageTest";
398 int64_t requestId = 555;
399 int32_t status = 2;
400 authManager->OnMemberJoin(requestId, status);
401 authManager->OnDataReceived(sessionId, message);
402 int32_t ret = authManager->SetPageId(pageId);
403 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
404 }
405
406 /**
407 * @tc.name: DmAuthManager::SetReasonAndFinish_001
408 * @tc.desc: Return ERR_DM_AUTH_NOT_START
409 * @tc.type: FUNC
410 * @tc.require: AR000GHSJK
411 */
412 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_001, testing::ext::TestSize.Level0)
413 {
414 std::shared_ptr<DmAuthManager> authManager =
415 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
416 const int32_t sessionId = 78;
417 int32_t reason = 123;
418 int32_t state = 456;
419 authManager->OnSessionClosed(sessionId);
420 authManager->authResponseContext_ = nullptr;
421 int64_t requestId = 333;
422 const std::string groupId = "{}";
423 authManager->OnGroupCreated(requestId, groupId);
424 int32_t ret = authManager->SetReasonAndFinish(reason, state);
425 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
426 }
427
428 /**
429 * @tc.name: DmAuthManager::SetReasonAndFinish_002
430 * @tc.desc: Return DM_OK
431 * @tc.type: FUNC
432 * @tc.require: AR000GHSJK
433 */
434 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_002, testing::ext::TestSize.Level0)
435 {
436 std::shared_ptr<DmAuthManager> authManager =
437 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
438 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
439 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
440 int32_t reason = 1234;
441 int32_t state = 5678;
442 int64_t requestId = 22;
443 const std::string groupId = "{}";
444 authManager->OnGroupCreated(requestId, groupId);
445 int32_t ret = authManager->SetReasonAndFinish(reason, state);
446 ASSERT_EQ(ret, DM_OK);
447 }
448
449 /**
450 * @tc.name: DmAuthManager::SetReasonAndFinish_003
451 * @tc.desc: Return DM_OK
452 * @tc.type: FUNC
453 * @tc.require: AR000GHSJK
454 */
455 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_003, testing::ext::TestSize.Level0)
456 {
457 std::shared_ptr<DmAuthManager> authManager =
458 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
459 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
460 authManager->authRequestState_ = nullptr;
461 authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
462 int32_t reason = 12;
463 int32_t state = 36;
464 int32_t ret = authManager->SetReasonAndFinish(reason, state);
465 ASSERT_EQ(ret, DM_OK);
466 }
467
468 /**
469 * @tc.name: DmAuthManager::IsIdenticalAccount_001
470 * @tc.desc: Return false
471 * @tc.type: FUNC
472 * @tc.require: AR000GHSJK
473 */
474 HWTEST_F(DmAuthManagerTest, IsIdenticalAccount_001, testing::ext::TestSize.Level0)
475 {
476 std::shared_ptr<DmAuthManager> authManager =
477 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
478 bool ret = authManager->IsIdenticalAccount();
479 ASSERT_EQ(ret, false);
480 }
481
482 /**
483 * @tc.name: DmAuthManager::GeneratePincode_001
484 * @tc.desc: Return OK
485 * @tc.type: FUNC
486 * @tc.require: AR000GHSJK
487 */
488 HWTEST_F(DmAuthManagerTest, GeneratePincode_001, testing::ext::TestSize.Level0)
489 {
490 std::shared_ptr<DmAuthManager> authManager =
491 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
492 int32_t openedSessionId = 66;
493 int32_t sessionSide = 0;
494 int32_t result = 3;
495 const int32_t closedSessionId = 11;
496 authManager->OnSessionOpened(openedSessionId, sessionSide, result);
497 authManager->OnSessionClosed(closedSessionId);
498 int32_t ret = authManager->GeneratePincode();
499 ASSERT_LE(ret, MAX_PIN_CODE);
500 ASSERT_GE(ret, MIN_PIN_CODE);
501 }
502
503 /**
504 * @tc.name: DmAuthManager::AuthenticateDevice_001
505 * @tc.desc: Return ERR_DM_AUTH_FAILED
506 * @tc.type: FUNC
507 * @tc.require: AR000GHSJK
508 */
509 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
510 {
511 std::shared_ptr<DmAuthManager> authManager =
512 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
513 std::string pkgName = "com.ohos.test";
514 int32_t authType = 0;
515 std::string deviceId = "113456";
516 std::string extra = "extraTest";
517 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
518 ASSERT_EQ(ret, ERR_DM_AUTH_FAILED);
519 }
520
521 /**
522 * @tc.name: DmAuthManager::AuthenticateDevice_002
523 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
524 * @tc.type: FUNC
525 * @tc.require: AR000GHSJK
526 */
527 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
528 {
529 std::shared_ptr<DmAuthManager> authManager =
530 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
531 std::string pkgName = "";
532 int32_t authType = 1;
533 std::string deviceId = "113456";
534 std::string extra = "extraTest";
535 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
536 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
537 }
538
539 /**
540 * @tc.name: DmAuthManager::AuthenticateDevice_003
541 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
542 * @tc.type: FUNC
543 * @tc.require: AR000GHSJK
544 */
545 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
546 {
547 std::shared_ptr<DmAuthManager> authManager =
548 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
549 std::string pkgName = "com.ohos.test";
550 int32_t authType = 1;
551 std::string deviceId = "234568";
552 std::string extra = "extraTest";
553 authManager->listener_ = nullptr;
554 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
555 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
556 }
557
558 /**
559 * @tc.name: DmAuthManager::AuthenticateDevice_004
560 * @tc.desc: Return ERR_DM_UNSUPPORTED_AUTH_TYPE
561 * @tc.type: FUNC
562 * @tc.require: AR000GHSJK
563 */
564 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)
565 {
566 std::shared_ptr<DmAuthManager> authManager =
567 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
568 std::string pkgName = "com.ohos.test";
569 int32_t authType = 4;
570 std::string deviceId = "deviceIdTest";
571 std::string extra = "extraTest";
572 authManager->authenticationMap_.emplace(authType, nullptr);
573 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
574 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_AUTH_TYPE);
575 }
576
577 /**
578 * @tc.name: DmAuthManager::AuthenticateDevice_005
579 * @tc.desc: Return ERR_DM_AUTH_BUSINESS_BUSY
580 * @tc.type: FUNC
581 * @tc.require: AR000GHSJK
582 */
583 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_005, testing::ext::TestSize.Level0)
584 {
585 std::shared_ptr<DmAuthManager> authManager =
586 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
587 std::string pkgName = "com.ohos.test";
588 int32_t authType = 1;
589 std::string deviceId = "deviceIdTest";
590 std::string extra = "extraTest";
591 authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
592 authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
593 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
594 ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
595 }
596
597 /**
598 * @tc.name: DmAuthManager::AuthenticateDevice_006
599 * @tc.desc: Return ERR_DM_INPUT_PARA_INVALID
600 * @tc.type: FUNC
601 * @tc.require: AR000GHSJK
602 */
603 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_006, testing::ext::TestSize.Level0)
604 {
605 std::shared_ptr<DmAuthManager> authManager =
606 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
607 std::string pkgName = "com.ohos.test";
608 int32_t authType = 1;
609 std::string deviceId = "deviceIdTest";
610 std::string extra = "extraTest";
611 const int32_t sessionId = 1;
612 authManager->authRequestState_ = nullptr;
613 authManager->authResponseState_ = nullptr;
614 authManager->authResponseContext_ = nullptr;
615 authManager->StartNegotiate(sessionId);
616 authManager->RespNegotiate(sessionId);
617 authManager->SendAuthRequest(sessionId);
618 authManager->StartRespAuthProcess();
619 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
620 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
621 }
622
623 /**
624 * @tc.name: DmAuthManager::AuthenticateDevice_007
625 * @tc.desc: Return DM_OK
626 * @tc.type: FUNC
627 * @tc.require: AR000GHSJK
628 */
629 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_007, testing::ext::TestSize.Level0)
630 {
631 std::shared_ptr<DmAuthManager> authManager =
632 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
633 std::string pkgName = "com.ohos.test";
634 int32_t authType = 1;
635 std::string deviceId = "deviceIdTest";
636 std::string extra = "extraTest";
637 std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
638 authManager->authRequestState_ = nullptr;
639 authManager->authResponseState_ = nullptr;
640 authManager->timer_ = nullptr;
641 authManager->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
642 int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
643 ASSERT_EQ(ret, DM_OK);
644 }
645
646 /**
647 * @tc.name: DmAuthManager::GenerateGroupName_001
648 * @tc.desc: Return DM_OK
649 * @tc.type: FUNC
650 * @tc.require: AR000GHSJK
651 */
652 HWTEST_F(DmAuthManagerTest, GenerateGroupName_001, testing::ext::TestSize.Level0)
653 {
654 std::shared_ptr<DmAuthManager> authManager =
655 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
656 authManager->authResponseContext_ = nullptr;
657 std::string ret = authManager->GenerateGroupName();
658 ASSERT_TRUE(ret.empty());
659 }
660
661 /**
662 * @tc.name: DmAuthManager::GenerateGroupName_002
663 * @tc.desc: Return DM_OK
664 * @tc.type: FUNC
665 * @tc.require: AR000GHSJK
666 */
667 HWTEST_F(DmAuthManagerTest, GenerateGroupName_002, testing::ext::TestSize.Level0)
668 {
669 std::shared_ptr<DmAuthManager> authManager =
670 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
671 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
672 authManager->authResponseContext_->targetPkgName = "targetPkgNameTest";
673 authManager->authResponseContext_->localDeviceId = "localDeviceIdTest";
674 std::string ret = authManager->GenerateGroupName();
675 ASSERT_TRUE(!ret.empty());
676 }
677
678 /**
679 * @tc.name: DmAuthManager::GetIsCryptoSupport_001
680 * @tc.desc: Set authResponseState_ is nullptr Return false
681 * @tc.type: FUNC
682 * @tc.require: AR000GHSJK
683 */
684 HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_001, testing::ext::TestSize.Level0)
685 {
686 std::shared_ptr<DmAuthManager> authManager =
687 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
688 authManager->authResponseState_ = nullptr;
689 bool ret = authManager->GetIsCryptoSupport();
690 ASSERT_EQ(ret, false);
691 }
692
693 /**
694 * @tc.name: DmAuthManager::GetIsCryptoSupport_002
695 * @tc.desc: Set authResponseState_ is not nullptr and authRequestState_ is nullptr Return false
696 * @tc.type: FUNC
697 * @tc.require: AR000GHSJK
698 */
699 HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_002, testing::ext::TestSize.Level0)
700 {
701 std::shared_ptr<DmAuthManager> authManager =
702 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
703 authManager->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
704 authManager->authRequestState_ = nullptr;
705 bool ret = authManager->GetIsCryptoSupport();
706 ASSERT_EQ(ret, false);
707 }
708
709 /**
710 * @tc.name: DmAuthManager::GetIsCryptoSupport_003
711 * @tc.desc: Set authResponseState_ is not nullptr and authRequestState_ is nullptr Return false
712 * @tc.type: FUNC
713 * @tc.require: AR000GHSJK
714 */
715 HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_003, testing::ext::TestSize.Level0)
716 {
717 std::shared_ptr<DmAuthManager> authManager =
718 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
719 authManager->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
720 authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
721 bool ret = authManager->GetIsCryptoSupport();
722 ASSERT_EQ(ret, false);
723 }
724
725 /**
726 * @tc.name: DmAuthManager::OnUserOperation_001
727 * @tc.desc: Set authResponseContext_ is nullptr Return ERR_DM_AUTH_NOT_START
728 * @tc.type: FUNC
729 * @tc.require: AR000GHSJK
730 */
731 HWTEST_F(DmAuthManagerTest, OnUserOperation_001, testing::ext::TestSize.Level0)
732 {
733 std::shared_ptr<DmAuthManager> authManager =
734 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
735 int32_t action = 0;
736 std::string params = "paramsTest";
737 authManager->authResponseContext_ = nullptr;
738 int32_t ret = authManager->OnUserOperation(action, params);
739 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
740 }
741
742 /**
743 * @tc.name: DmAuthManager::OnUserOperation_002
744 * @tc.desc: Set authResponseContext_ is not nullptr Return DM_OK
745 * @tc.type: FUNC
746 * @tc.require: AR000GHSJK
747 */
748 HWTEST_F(DmAuthManagerTest, OnUserOperation_002, testing::ext::TestSize.Level0)
749 {
750 std::shared_ptr<DmAuthManager> authManager =
751 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
752 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
753 authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
754 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
755 int32_t action = 1;
756 std::string params = "paramsTest1";
757 int32_t ret = authManager->OnUserOperation(action, params);
758 ASSERT_EQ(ret, DM_OK);
759 }
760
761 /**
762 * @tc.name: DmAuthManager::OnUserOperation_003
763 * @tc.desc: Set authResponseContext_ is not nullptr Return DM_OK
764 * @tc.type: FUNC
765 * @tc.require: AR000GHSJK
766 */
767 HWTEST_F(DmAuthManagerTest, OnUserOperation_003, testing::ext::TestSize.Level0)
768 {
769 std::shared_ptr<DmAuthManager> authManager =
770 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
771 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
772 int32_t action = 2;
773 std::string params = "paramsTest2";
774 int32_t ret = authManager->OnUserOperation(action, params);
775 ASSERT_EQ(ret, DM_OK);
776 }
777
778 /**
779 * @tc.name: DmAuthManager::OnUserOperation_004
780 * @tc.desc: Set authResponseContext_ is not nullptr Return DM_OK
781 * @tc.type: FUNC
782 * @tc.require: AR000GHSJK
783 */
784 HWTEST_F(DmAuthManagerTest, OnUserOperation_004, testing::ext::TestSize.Level0)
785 {
786 std::shared_ptr<DmAuthManager> authManager =
787 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
788 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
789 int32_t action = 3;
790 std::string params = "paramsTest3";
791 int32_t ret = authManager->OnUserOperation(action, params);
792 ASSERT_EQ(ret, DM_OK);
793 }
794
795 /**
796 * @tc.name: DmAuthManager::OnUserOperation_005
797 * @tc.desc: Set authResponseContext_ is not nullptr Return DM_OK
798 * @tc.type: FUNC
799 * @tc.require: AR000GHSJK
800 */
801 HWTEST_F(DmAuthManagerTest, OnUserOperation_005, testing::ext::TestSize.Level0)
802 {
803 std::shared_ptr<DmAuthManager> authManager =
804 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
805 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
806 int32_t action = 4;
807 std::string params = "paramsTest4";
808 int32_t ret = authManager->OnUserOperation(action, params);
809 ASSERT_EQ(ret, DM_OK);
810 }
811
812 /**
813 * @tc.name: DmAuthManager::OnUserOperation_006
814 * @tc.desc: Set authResponseContext_ is not nullptr Return DM_OK
815 * @tc.type: FUNC
816 * @tc.require: AR000GHSJK
817 */
818 HWTEST_F(DmAuthManagerTest, OnUserOperation_006, testing::ext::TestSize.Level0)
819 {
820 std::shared_ptr<DmAuthManager> authManager =
821 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
822 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
823 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
824 authManager->timer_ = std::make_shared<DmTimer>();
825 int32_t action = 5;
826 std::string params = "5";
827 int32_t ret = authManager->OnUserOperation(action, params);
828 ASSERT_EQ(ret, DM_OK);
829 }
830
831 /**
832 * @tc.name: DmAuthManager::OnUserOperation_007
833 * @tc.desc: Set authResponseContext_ is not nullptr Return DM_OK
834 * @tc.type: FUNC
835 * @tc.require: AR000GHSJK
836 */
837 HWTEST_F(DmAuthManagerTest, OnUserOperation_007, testing::ext::TestSize.Level0)
838 {
839 std::shared_ptr<DmAuthManager> authManager =
840 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
841 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
842 int32_t action = 1111;
843 std::string params = "paramsTest1111";
844 int32_t ret = authManager->OnUserOperation(action, params);
845 ASSERT_EQ(ret, DM_OK);
846 }
847
848 /**
849 * @tc.name: DmAuthManager::UnBindDevice001
850 * @tc.desc: Set pkgName not null
851 * Set udidHash not null
852 * @tc.type: FUNC
853 */
854 HWTEST_F(DmAuthManagerTest, UnBindDevice001, testing::ext::TestSize.Level0)
855 {
856 std::shared_ptr<DmAuthManager> authManager =
857 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
858 std::string pkgName = "com.ohos.test";
859 std::string udidHash = "udidHash";
860 int32_t ret = authManager->UnBindDevice(pkgName, udidHash);
861 ASSERT_EQ(ret, ERR_DM_FAILED);
862 }
863
864 /**
865 * @tc.name: DmAuthManager::UnBindDevice002
866 * @tc.desc: Set pkgName not null
867 * Set udidHash not null
868 * @tc.type: FUNC
869 */
870 HWTEST_F(DmAuthManagerTest, UnBindDevice002, testing::ext::TestSize.Level0)
871 {
872 std::shared_ptr<DmAuthManager> authManager =
873 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
874 std::string pkgName;
875 std::string udidHash = "udidHash";
876 int32_t ret = authManager->UnBindDevice(pkgName, udidHash);
877 ASSERT_EQ(ret, ERR_DM_FAILED);
878 }
879 } // namespace
880 } // namespace DistributedHardware
881 } // namespace OHOS
882