1 /*
2 * Copyright (c) 2022 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_auth_request_state.h"
17
18 #include "auth_message_processor.h"
19 #include "dm_auth_manager.h"
20 #include "dm_constants.h"
21 #include "device_manager_service_listener.h"
22
23 namespace OHOS {
24 namespace DistributedHardware {
SetUp()25 void AuthRequestStateTest::SetUp()
26 {
27 }
TearDown()28 void AuthRequestStateTest::TearDown()
29 {
30 }
SetUpTestCase()31 void AuthRequestStateTest::SetUpTestCase()
32 {
33 }
TearDownTestCase()34 void AuthRequestStateTest::TearDownTestCase()
35 {
36 }
37
38 namespace {
39 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
40 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
41 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
42 /**
43 * @tc.name: AuthResponseInitState::Leave_001
44 * @tc.desc: 1 set authManager not null
45 * 2 call AuthResponseInitState::Leave with authManager ！= null
46 * 3 check ret is authResponseState->authManager_.use_count()
47 * @tc.type: FUNC
48 * @tc.require: AR000GHSJK
49 */
50 HWTEST_F(AuthRequestStateTest, Leave_001, testing::ext::TestSize.Level0)
51 {
52 std::shared_ptr<DmAuthManager> authManager =
53 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
54 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
55 int32_t ret = authRequestState->Leave();
56 ASSERT_EQ(ret, DM_OK);
57 }
58
59 /**
60 * @tc.name: AuthRequestInitState::SetAuthContext_001
61 * @tc.desc: 1 set authManager not null
62 * 2 call AuthRequestInitState::SetAuthManager with authManager ！= null
63 * 3 check ret is authResponseState->authManager_.use_count()
64 * @tc.type: FUNC
65 * @tc.require: AR000GHSJK
66 */
67 HWTEST_F(AuthRequestStateTest, SetAuthContext_001, testing::ext::TestSize.Level0)
68 {
69 std::shared_ptr<DmAuthManager> authManager =
70 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
71 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
72 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
73 authRequestState->SetAuthContext(context);
74 int32_t ret = authRequestState->context_.use_count();
75 authRequestState->context_.reset();
76 ASSERT_EQ(ret, 2);
77 }
78
79 /**
80 * @tc.name: AuthRequestInitState::SetAuthManager_002
81 * @tc.desc: 1 set authManager to null
82 * 2 call AuthRequestInitState::SetAuthManager with authManager = null
83 * 3 check ret is authResponseState->authManager_.use_count()
84 * @tc.type: FUNC
85 * @tc.require: AR000GHSJK
86 */
87 HWTEST_F(AuthRequestStateTest, SetAuthContext_002, testing::ext::TestSize.Level0)
88 {
89 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
90 authRequestState->SetAuthContext(nullptr);
91 int32_t ret = authRequestState->authManager_.use_count();
92 authRequestState->authManager_.reset();
93 ASSERT_EQ(ret, 0);
94 }
95
96 /**
97 * @tc.name: AuthRequestInitState::GetAuthContext_001
98 * @tc.desc: 1 set authManager not null
99 * 2 call AuthRequestInitState::GetAuthContext with authManager ！= null
100 * 3 check ret is authResponseState->authManager_.use_count()
101 * @tc.type: FUNC
102 * @tc.require: AR000GHSJK
103 */
104 HWTEST_F(AuthRequestStateTest, GetAuthContext_001, testing::ext::TestSize.Level0)
105 {
106 std::shared_ptr<DmAuthManager> authManager =
107 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
108 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
109 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
110 authRequestState->GetAuthContext();
111 int32_t ret = authRequestState->context_.use_count();
112 authRequestState->context_.reset();
113 ASSERT_EQ(ret, 0);
114 }
115
116 /**
117 * @tc.name: AuthRequestInitState::SetAuthManager_001
118 * @tc.desc: 1 set authManager not null
119 * 2 call AuthRequestInitState::SetAuthManager with authManager ！= null
120 * 3 check ret is authResponseState->authManager_.use_count()
121 * @tc.type: FUNC
122 * @tc.require: AR000GHSJK
123 */
124 HWTEST_F(AuthRequestStateTest, SetAuthManager_001, testing::ext::TestSize.Level0)
125 {
126 std::shared_ptr<DmAuthManager> authManager =
127 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
128 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
129 authRequestState->SetAuthManager(authManager);
130 int32_t ret = authRequestState->authManager_.use_count();
131 authRequestState->authManager_.reset();
132 ASSERT_EQ(ret, 1);
133 }
134
135 /**
136 * @tc.name: AuthRequestInitState::SetAuthManager_002
137 * @tc.desc: 1 set authManager to null
138 * 2 call AuthRequestInitState::SetAuthManager with authManager = null
139 * 3 check ret is authResponseState->authManager_.use_count()
140 * @tc.type: FUNC
141 * @tc.require: AR000GHSJK
142 */
143 HWTEST_F(AuthRequestStateTest, SetAuthManager_002, testing::ext::TestSize.Level0)
144 {
145 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
146 authRequestState->SetAuthManager(nullptr);
147 int32_t ret = authRequestState->authManager_.use_count();
148 authRequestState->authManager_.reset();
149 ASSERT_EQ(ret, 0);
150 }
151
152 /**
153 * @tc.name: AuthRequestNegotiateState::TransitionTo_001
154 * @tc.desc: 1 set authManager to null
155 * 2 call AuthRequestInitState::TransitionTo with authManager = null
156 * 4 check ret is ERR_DM_FAILED
157 * @tc.type: FUNC
158 * @tc.require: AR000GHSJK
159 */
160 HWTEST_F(AuthRequestStateTest, TransitionTo_001, testing::ext::TestSize.Level0)
161 {
162 std::shared_ptr<DmAuthManager> authManager =
163 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
164 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
165 authManager = nullptr;
166 authRequestState->authManager_ = authManager;
167 int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateState>());
168 ASSERT_EQ(ret, ERR_DM_FAILED);
169 }
170
171 /**
172 * @tc.name: AuthRequestInitState::TransitionTo_002
173 * @tc.desc: 1 set authManager not null
174 * 2 call AuthRequestInitState::TransitionTo with authManager != null
175 * 4 check ret is DM_OK
176 * @tc.type: FUNC
177 * @tc.require: AR000GHSJK
178 */
179 HWTEST_F(AuthRequestStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
180 {
181 std::shared_ptr<DmAuthManager> authManager =
182 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
183 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
184 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
185 authManager->timer_ = std::make_shared<DmTimer>();
186 authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
187 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
188 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
189 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
190 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
191 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
192 context->sessionId = 123456;
193 authManager->SetAuthRequestState(authRequestState);
194 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
195 authRequestState->SetAuthContext(context);
196 authRequestState->SetAuthManager(authManager);
197 int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateDoneState>());
198 ASSERT_EQ(ret, DM_OK);
199 }
200
201 /**
202 * @tc.name: AuthRequestInitState::GetStateType_001
203 * @tc.desc: 1 call AuthRequestInitState::GetStateType
204 * 2 check ret is AuthState::AUTH_RESPONSE_INIT
205 * @tc.type: FUNC
206 * @tc.require: AR000GHSJK
207 */
208 HWTEST_F(AuthRequestStateTest, GetStateType_001, testing::ext::TestSize.Level0)
209 {
210 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
211 int32_t ret = authRequestState->GetStateType();
212 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_INIT);
213 }
214
215 /**
216 * @tc.name: AuthRequestInitState::Enter_001
217 * @tc.desc: 1 set authManager to null
218 * 2 call AuthRequestInitState::Enter with authManager = null
219 * 3 check ret is ERR_DM_FAILED
220 * @tc.type: FUNC
221 * @tc.require: AR000GHSJK
222 */
223 HWTEST_F(AuthRequestStateTest, Enter_001, testing::ext::TestSize.Level0)
224 {
225 std::shared_ptr<DmAuthManager> authManager =
226 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
227 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
228 authManager = nullptr;
229 authRequestState->SetAuthManager(authManager);
230 int32_t ret = authRequestState->Enter();
231 ASSERT_EQ(ret, ERR_DM_FAILED);
232 }
233
234 /**
235 * @tc.name: AuthRequestInitState::Enter_002
236 * @tc.desc: 1 set authManager not null
237 * 2 call AuthRequestInitState::Enter with authManager != null
238 * 3 check ret is ERR_DM_FAILED
239 * @tc.type: FUNC
240 * @tc.require: AR000GHSJK
241 */
242 HWTEST_F(AuthRequestStateTest, Enter_002, testing::ext::TestSize.Level0)
243 {
244 std::shared_ptr<DmAuthManager> authManager =
245 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
246 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
247 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
248 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
249 authManager->authRequestState_ = std::make_shared<AuthRequestInitState>();
250 authRequestState->SetAuthManager(authManager);
251 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
252 context->deviceId = "123456";
253 authRequestState->SetAuthContext(context);
254 int32_t ret = authRequestState->Enter();
255 ASSERT_EQ(ret, DM_OK);
256 }
257
258 /**
259 * @tc.name: AuthRequestNegotiateState::GetStateType_002
260 * @tc.desc: 1 call AuthRequestNegotiateState::GetStateType
261 * 2 check ret is AuthState::AUTH_RESPONSE_NEGOTIATE
262 * @tc.type: FUNC
263 * @tc.require: AR000GHSJK
264 */
265 HWTEST_F(AuthRequestStateTest, GetStateType_002, testing::ext::TestSize.Level0)
266 {
267 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
268 int32_t ret = authRequestState->GetStateType();
269 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE);
270 }
271
272 /**
273 * @tc.name: AuthRequestNegotiateState::Enter_001
274 * @tc.desc: 1 set authManager to null
275 * 2 call AuthRequestNegotiateState::Enter with authManager = null
276 * 3 check ret is ERR_DM_FAILED
277 * @tc.type: FUNC
278 * @tc.require: AR000GHSJK
279 */
280 HWTEST_F(AuthRequestStateTest, Enter_003, testing::ext::TestSize.Level0)
281 {
282 std::shared_ptr<DmAuthManager> authManager =
283 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
284 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
285 authRequestState->SetAuthManager(nullptr);
286 int32_t ret = authRequestState->Enter();
287 ASSERT_EQ(ret, ERR_DM_FAILED);
288 }
289
290 /**
291 * @tc.name: AuthRequestNegotiateState::Enter_004
292 * @tc.desc: 1 set authManager not null
293 * 2 call AuthRequestNegotiateState::Enter with authManager != null
294 * 3 check ret is DM_OK
295 * @tc.type: FUNC
296 * @tc.require: AR000GHSJK
297 */
298 HWTEST_F(AuthRequestStateTest, Enter_004, testing::ext::TestSize.Level0)
299 {
300 std::shared_ptr<DmAuthManager> authManager =
301 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
302 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
303 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
304 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
305 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
306 authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
307 authManager->authRequestContext_->deviceId = "111";
308 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
309 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
310 authManager->timer_ = std::make_shared<DmTimer>();
311 authRequestState->SetAuthManager(authManager);
312 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
313 context->deviceId = "123456";
314 context->sessionId = 22222;
315 authRequestState->SetAuthContext(context);
316 int32_t ret = authRequestState->Enter();
317 ASSERT_EQ(ret, DM_OK);
318 }
319
320 /**
321 * @tc.name: AuthRequestNegotiateDoneState::GetStateType_003
322 * @tc.desc: 1 call AuthRequestNegotiateDoneState::GetStateType
323 * 2 check ret is AuthState::AUTH_REQUEST_NEGOTIATE_DONE
324 * @tc.type: FUNC
325 * @tc.require: AR000GHSJK
326 */
327 HWTEST_F(AuthRequestStateTest, GetStateType_003, testing::ext::TestSize.Level0)
328 {
329 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
330 int32_t ret = authRequestState->GetStateType();
331 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE_DONE);
332 }
333
334 /**
335 * @tc.name: AuthRequestNegotiateDoneState::Enter_005
336 * @tc.desc: 1 set authManager to null
337 * 2 call AuthRequestNegotiateDoneState::Enter with authManager = null
338 * 3 check ret is ERR_DM_FAILED
339 * @tc.type: FUNC
340 * @tc.require: AR000GHSJK
341 */
342 HWTEST_F(AuthRequestStateTest, Enter_005, testing::ext::TestSize.Level0)
343 {
344 std::shared_ptr<DmAuthManager> authManager =
345 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
346 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
347 authRequestState->SetAuthManager(nullptr);
348 int32_t ret = authRequestState->Enter();
349 ASSERT_EQ(ret, ERR_DM_FAILED);
350 }
351
352 /**
353 * @tc.name: AuthRequestNegotiateDoneState::Enter_006
354 * @tc.desc: 1 set authManager not null
355 * 2 call AuthRequestNegotiateDoneState::Enter with authManager != null
356 * 3 check ret is DM_OK
357 * @tc.type: FUNC
358 * @tc.require: AR000GHSJK
359 */
360 HWTEST_F(AuthRequestStateTest, Enter_006, testing::ext::TestSize.Level0)
361 {
362 std::shared_ptr<DmAuthManager> authManager =
363 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
364 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
365 authManager->timer_ = std::make_shared<DmTimer>();
366 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
367 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
368 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
369 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
370 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
371 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
372 authManager->SetAuthRequestState(authRequestState);
373 authRequestState->SetAuthManager(authManager);
374 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
375 context->sessionId = 333333;
376 authRequestState->SetAuthContext(context);
377 int32_t ret = authRequestState->Enter();
378 ASSERT_EQ(ret, DM_OK);
379 }
380
381 /**
382 * @tc.name: AuthRequestReplyState::GetStateType_004
383 * @tc.desc: 1 call AuthRequestReplyState::GetStateType
384 * 2 check ret is AuthState::AUTH_REQUEST_REPLY
385 * @tc.type: FUNC
386 * @tc.require: AR000GHSJK
387 */
388 HWTEST_F(AuthRequestStateTest, GetStateType_004, testing::ext::TestSize.Level0)
389 {
390 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
391 int32_t ret = authRequestState->GetStateType();
392 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_REPLY);
393 }
394
395 /**
396 * @tc.name: AuthRequestReplyState::Enter_007
397 * @tc.desc: 1 set authManager to null
398 * 2 call AuthRequestReplyState::Enter with authManager = null
399 * 3 check ret is ERR_DM_FAILED
400 * @tc.type: FUNC
401 * @tc.require: AR000GHSJK
402 */
403 HWTEST_F(AuthRequestStateTest, Enter_007, testing::ext::TestSize.Level0)
404 {
405 std::shared_ptr<DmAuthManager> authManager =
406 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
407 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
408 authRequestState->SetAuthManager(nullptr);
409 int32_t ret = authRequestState->Enter();
410 ASSERT_EQ(ret, ERR_DM_FAILED);
411 }
412
413 /**
414 * @tc.name: AuthRequestReplyState::Enter_008
415 * @tc.desc: 1 set authManager not null
416 * 2 call AuthRequestReplyState::Enter with authManager != null
417 * 3 check ret is DM_OK
418 * @tc.type: FUNC
419 * @tc.require: AR000GHSJK
420 */
421 HWTEST_F(AuthRequestStateTest, Enter_008, testing::ext::TestSize.Level0)
422 {
423 std::shared_ptr<DmAuthManager> authManager =
424 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
425 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
426 authManager->timer_ = std::make_shared<DmTimer>();
427 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
428 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
429 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
430 authManager->authRequestState_ = std::make_shared<AuthRequestReplyState>();
431 authManager->authResponseContext_->sessionId = 1;
432 authManager->authPtr_ = authManager->authenticationMap_[1];
433 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
434 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
435 authManager->SetAuthRequestState(authRequestState);
436 authRequestState->SetAuthManager(authManager);
437 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
438 context->sessionId = 333333;
439 authRequestState->SetAuthContext(context);
440 int32_t ret = authRequestState->Enter();
441 ASSERT_EQ(ret, DM_OK);
442 }
443
444 /**
445 * @tc.name: AuthRequestJoinState::GetStateType_006
446 * @tc.desc: 1 call AuthRequestJoinState::GetStateType
447 * 2 check ret is AuthState::AUTH_REQUEST_JOIN
448 * @tc.type: FUNC
449 * @tc.require: AR000GHSJK
450 */
451 HWTEST_F(AuthRequestStateTest, GetStateType_006, testing::ext::TestSize.Level0)
452 {
453 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
454 int32_t ret = authRequestState->GetStateType();
455 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_JOIN);
456 }
457
458 /**
459 * @tc.name: AuthRequestJoinState::Enter_011
460 * @tc.desc: 1 set authManager to null
461 * 2 call AuthRequestJoinState::Enter with authManager = null
462 * 3 check ret is ERR_DM_FAILED
463 * @tc.type: FUNC
464 * @tc.require: AR000GHSJK
465 */
466 HWTEST_F(AuthRequestStateTest, Enter_011, testing::ext::TestSize.Level0)
467 {
468 std::shared_ptr<DmAuthManager> authManager =
469 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
470 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
471 authRequestState->SetAuthManager(nullptr);
472 int32_t ret = authRequestState->Enter();
473 ASSERT_EQ(ret, ERR_DM_FAILED);
474 }
475
476 /**
477 * @tc.name: AuthRequestJoinState::Enter_012
478 * @tc.desc: 1 set authManager not null
479 * 2 call AuthRequestJoinState::Enter with authManager != null
480 * 3 check ret is DM_OK
481 * @tc.type: FUNC
482 * @tc.require: AR000GHSJK
483 */
484 HWTEST_F(AuthRequestStateTest, Enter_012, testing::ext::TestSize.Level0)
485 {
486 std::shared_ptr<DmAuthManager> authManager =
487 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
488 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
489 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
490 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
491 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
492 authManager->authPtr_ = authManager->authenticationMap_[1];
493 authManager->authResponseContext_->groupId = "111";
494 authManager->authResponseContext_->groupName = "222";
495 authManager->authResponseContext_->code = 123;
496 authManager->authResponseContext_->requestId = 234;
497 authManager->authResponseContext_->deviceId = "234";
498 authRequestState->SetAuthManager(authManager);
499 authManager->timer_ = std::make_shared<DmTimer>();
500 authManager->SetAuthRequestState(authRequestState);
501 authManager->hiChainConnector_->RegisterHiChainCallback(authManager);
502 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
503 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
504 context->deviceId = "44444";
505 context->sessionId = 55555;
506 authRequestState->SetAuthContext(context);
507 int32_t ret = authRequestState->Enter();
508 ASSERT_EQ(ret, DM_OK);
509 }
510
511 /**
512 * @tc.name: AuthRequestNetworkState::GetStateType_007
513 * @tc.desc: 1 call AuthRequestNetworkState::GetStateType
514 * 2 check ret is AuthState::AUTH_REQUEST_NETWORK
515 * @tc.type: FUNC
516 * @tc.require: AR000GHSJK
517 */
518 HWTEST_F(AuthRequestStateTest, GetStateType_007, testing::ext::TestSize.Level0)
519 {
520 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
521 int32_t ret = authRequestState->GetStateType();
522 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NETWORK);
523 }
524
525 /**
526 * @tc.name: AuthRequestNetworkState::Enter_013
527 * @tc.desc: 1 set authManager to null
528 * 2 call AuthRequestNetworkState::Enter with authManager = null
529 * 3 check ret is ERR_DM_FAILED
530 * @tc.type: FUNC
531 * @tc.require: AR000GHSJK
532 */
533 HWTEST_F(AuthRequestStateTest, Enter_013, testing::ext::TestSize.Level0)
534 {
535 std::shared_ptr<DmAuthManager> authManager =
536 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
537 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
538 authRequestState->SetAuthManager(nullptr);
539 int32_t ret = authRequestState->Enter();
540 ASSERT_EQ(ret, ERR_DM_FAILED);
541 }
542
543 /**
544 * @tc.name: AuthRequestNetworkState::Enter_014
545 * @tc.desc: 1 set authManager not null
546 * 2 call AuthRequestNetworkState::Enter with authManager != null
547 * 3 check ret is DM_OK
548 * @tc.type: FUNC
549 * @tc.require: AR000GHSJK
550 */
551 HWTEST_F(AuthRequestStateTest, Enter_014, testing::ext::TestSize.Level0)
552 {
553 std::shared_ptr<DmAuthManager> authManager =
554 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
555 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
556 authManager->timer_ = std::make_shared<DmTimer>();
557 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
558 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
559 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
560 authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
561 authManager->authPtr_ = authManager->authenticationMap_[1];
562 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
563 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
564 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
565 authManager->SetAuthRequestState(authRequestState);
566 authRequestState->SetAuthManager(authManager);
567 int32_t ret = authRequestState->Enter();
568 ASSERT_EQ(ret, DM_OK);
569 }
570
571 /**
572 * @tc.name: AuthRequestFinishState::GetStateType_008
573 * @tc.desc: 1 call AuthRequestFinishState::GetStateType
574 * 2 check ret is AuthState::AUTH_REQUEST_FINISH
575 * @tc.type: FUNC
576 * @tc.require: AR000GHSJK
577 */
578 HWTEST_F(AuthRequestStateTest, GetStateType_008, testing::ext::TestSize.Level0)
579 {
580 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
581 int32_t ret = authRequestState->GetStateType();
582 ASSERT_EQ(ret, AuthState::AUTH_REQUEST_FINISH);
583 }
584
585 /**
586 * @tc.name: AuthRequestFinishState::Enter_015
587 * @tc.desc: 1 set authManager to null
588 * 2 call AuthRequestFinishState::Enter with authManager = null
589 * 3 check ret is ERR_DM_FAILED
590 * @tc.type: FUNC
591 * @tc.require: AR000GHSJK
592 */
593 HWTEST_F(AuthRequestStateTest, Enter_015, testing::ext::TestSize.Level0)
594 {
595 std::shared_ptr<DmAuthManager> authManager =
596 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
597 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
598 authRequestState->SetAuthManager(nullptr);
599 int32_t ret = authRequestState->Enter();
600 ASSERT_EQ(ret, ERR_DM_FAILED);
601 }
602
603 /**
604 * @tc.name: AuthRequestFinishState::Enter_016
605 * @tc.desc: 1 set authManager not null
606 * 2 call AuthRequestNetworkState::Enter with authManager != null
607 * 3 check ret is DM_OK
608 * @tc.type: FUNC
609 * @tc.require: AR000GHSJK
610 */
611 HWTEST_F(AuthRequestStateTest, Enter_016, testing::ext::TestSize.Level0)
612 {
613 std::shared_ptr<DmAuthManager> authManager =
614 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
615 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
616 authManager->timer_ = std::make_shared<DmTimer>();
617 authManager->authPtr_ = authManager->authenticationMap_[1];
618 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
619 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
620 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
621 authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
622 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
623 authManager->authResponseContext_->sessionId = 1;
624 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
625 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
626 authManager->SetAuthRequestState(authRequestState);
627 authRequestState->SetAuthManager(authManager);
628 std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
629 context->sessionId = 333333;
630 authRequestState->SetAuthContext(context);
631 int32_t ret = authRequestState->Enter();
632 ASSERT_EQ(ret, DM_OK);
633 }
634 } // namespace
635 } // namespace DistributedHardware
636 } // namespace OHOS
637