1 /*
2  * Copyright (c) 2022-2024 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 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
43 
44 /**
45  * @tc.name: AuthResponseInitState::Leave_001
46  * @tc.desc: 1 set authManager not null
47  *           2 call AuthResponseInitState::Leave with authManager ！= null
48  *           3 check ret is authResponseState->authManager_.use_count()
49  * @tc.type: FUNC
50  * @tc.require: AR000GHSJK
51  */
52 HWTEST_F(AuthRequestStateTest, Leave_001, testing::ext::TestSize.Level0)
53 {
54     std::shared_ptr<DmAuthManager> authManager =
55         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
56     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
57     int32_t ret = authRequestState->Leave();
58     ASSERT_EQ(ret, DM_OK);
59 }
60 
61 /**
62  * @tc.name: AuthRequestInitState::SetAuthContext_001
63  * @tc.desc: 1 set authManager not null
64  *           2 call AuthRequestInitState::SetAuthManager with authManager ！= null
65  *           3 check ret is authResponseState->authManager_.use_count()
66  * @tc.type: FUNC
67  * @tc.require: AR000GHSJK
68  */
69 HWTEST_F(AuthRequestStateTest, SetAuthContext_001, testing::ext::TestSize.Level0)
70 {
71     std::shared_ptr<DmAuthManager> authManager =
72         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
73     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
74     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
75     authRequestState->SetAuthContext(context);
76     int32_t ret = authRequestState->context_.use_count();
77     authRequestState->context_.reset();
78     ASSERT_EQ(ret, 2);
79 }
80 
81 /**
82  * @tc.name: AuthRequestInitState::SetAuthManager_002
83  * @tc.desc: 1 set authManager to null
84  *           2 call AuthRequestInitState::SetAuthManager with authManager = null
85  *           3 check ret is authResponseState->authManager_.use_count()
86  * @tc.type: FUNC
87  * @tc.require: AR000GHSJK
88  */
89 HWTEST_F(AuthRequestStateTest, SetAuthContext_002, testing::ext::TestSize.Level0)
90 {
91     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
92     authRequestState->SetAuthContext(nullptr);
93     int32_t ret = authRequestState->authManager_.use_count();
94     authRequestState->authManager_.reset();
95     ASSERT_EQ(ret, 0);
96 }
97 
98 /**
99  * @tc.name: AuthRequestInitState::GetAuthContext_001
100  * @tc.desc: 1 set authManager not null
101  *           2 call AuthRequestInitState::GetAuthContext with authManager ！= null
102  *           3 check ret is authResponseState->authManager_.use_count()
103  * @tc.type: FUNC
104  * @tc.require: AR000GHSJK
105  */
106 HWTEST_F(AuthRequestStateTest, GetAuthContext_001, testing::ext::TestSize.Level0)
107 {
108     std::shared_ptr<DmAuthManager> authManager =
109         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
110     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
111     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
112     authRequestState->GetAuthContext();
113     int32_t ret = authRequestState->context_.use_count();
114     authRequestState->context_.reset();
115     ASSERT_EQ(ret, 0);
116 }
117 
118 /**
119  * @tc.name: AuthRequestInitState::SetAuthManager_001
120  * @tc.desc: 1 set authManager not null
121  *           2 call AuthRequestInitState::SetAuthManager with authManager ！= null
122  *           3 check ret is authResponseState->authManager_.use_count()
123  * @tc.type: FUNC
124  * @tc.require: AR000GHSJK
125  */
126 HWTEST_F(AuthRequestStateTest, SetAuthManager_001, testing::ext::TestSize.Level0)
127 {
128     std::shared_ptr<DmAuthManager> authManager =
129         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
130     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
131     authRequestState->SetAuthManager(authManager);
132     int32_t ret = authRequestState->authManager_.use_count();
133     authRequestState->authManager_.reset();
134     ASSERT_EQ(ret, 1);
135 }
136 
137 /**
138  * @tc.name: AuthRequestInitState::SetAuthManager_002
139  * @tc.desc: 1 set authManager to null
140  *           2 call AuthRequestInitState::SetAuthManager with authManager = null
141  *           3 check ret is authResponseState->authManager_.use_count()
142  * @tc.type: FUNC
143  * @tc.require: AR000GHSJK
144  */
145 HWTEST_F(AuthRequestStateTest, SetAuthManager_002, testing::ext::TestSize.Level0)
146 {
147     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
148     authRequestState->SetAuthManager(nullptr);
149     int32_t ret = authRequestState->authManager_.use_count();
150     authRequestState->authManager_.reset();
151     ASSERT_EQ(ret, 0);
152 }
153 
154 /**
155  * @tc.name: AuthRequestNegotiateState::TransitionTo_001
156  * @tc.desc: 1 set authManager to null
157  *           2 call AuthRequestInitState::TransitionTo with authManager = null
158  *           4 check ret is ERR_DM_FAILED
159  * @tc.type: FUNC
160  * @tc.require: AR000GHSJK
161  */
162 HWTEST_F(AuthRequestStateTest, TransitionTo_001, testing::ext::TestSize.Level0)
163 {
164     std::shared_ptr<DmAuthManager> authManager =
165         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
166     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
167     authManager = nullptr;
168     authRequestState->authManager_ = authManager;
169     int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateState>());
170     ASSERT_EQ(ret, ERR_DM_FAILED);
171 }
172 
173 /**
174  * @tc.name: AuthRequestInitState::TransitionTo_002
175  * @tc.desc: 1 set authManager not null
176  *           2 call AuthRequestInitState::TransitionTo with authManager != null
177  *           4 check ret is DM_OK
178  * @tc.type: FUNC
179  * @tc.require: AR000GHSJK
180  */
181 HWTEST_F(AuthRequestStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
182 {
183     std::shared_ptr<DmAuthManager> authManager =
184         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
185     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
186     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
187     authManager->timer_ = std::make_shared<DmTimer>();
188     authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
189     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
190     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
191     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
192     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
193     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
194     context->sessionId = 123456;
195     authManager->SetAuthRequestState(authRequestState);
196     authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
197     authRequestState->SetAuthContext(context);
198     authRequestState->SetAuthManager(authManager);
199     int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateDoneState>());
200     ASSERT_EQ(ret, DM_OK);
201 }
202 
203 /**
204  * @tc.name: AuthRequestInitState::GetStateType_001
205  * @tc.desc: 1 call AuthRequestInitState::GetStateType
206  *           2 check ret is AuthState::AUTH_RESPONSE_INIT
207  * @tc.type: FUNC
208  * @tc.require: AR000GHSJK
209  */
210 HWTEST_F(AuthRequestStateTest, GetStateType_001, testing::ext::TestSize.Level0)
211 {
212     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
213     int32_t ret = authRequestState->GetStateType();
214     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_INIT);
215 }
216 
217 /**
218  * @tc.name: AuthRequestInitState::Enter_001
219  * @tc.desc: 1 set authManager to null
220  *           2 call AuthRequestInitState::Enter with authManager = null
221  *           3 check ret is ERR_DM_FAILED
222  * @tc.type: FUNC
223  * @tc.require: AR000GHSJK
224  */
225 HWTEST_F(AuthRequestStateTest, Enter_001, testing::ext::TestSize.Level0)
226 {
227     std::shared_ptr<DmAuthManager> authManager =
228         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
229     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
230     authManager = nullptr;
231     authRequestState->SetAuthManager(authManager);
232     int32_t ret = authRequestState->Enter();
233     ASSERT_EQ(ret, ERR_DM_FAILED);
234 }
235 
236 /**
237  * @tc.name: AuthRequestInitState::Enter_002
238  * @tc.desc: 1 set authManager not null
239  *           2 call AuthRequestInitState::Enter with authManager != null
240  *           3 check ret is ERR_DM_FAILED
241  * @tc.type: FUNC
242  * @tc.require: AR000GHSJK
243  */
244 HWTEST_F(AuthRequestStateTest, Enter_002, testing::ext::TestSize.Level0)
245 {
246     std::shared_ptr<DmAuthManager> authManager =
247         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
248     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
249     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
250     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
251     authManager->authRequestState_ = std::make_shared<AuthRequestInitState>();
252     authRequestState->SetAuthManager(authManager);
253     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
254     context->deviceId = "123456";
255     authRequestState->SetAuthContext(context);
256     int32_t ret = authRequestState->Enter();
257     ASSERT_EQ(ret, DM_OK);
258 }
259 
260 /**
261  * @tc.name: AuthRequestNegotiateState::GetStateType_002
262  * @tc.desc: 1 call AuthRequestNegotiateState::GetStateType
263  *           2 check ret is AuthState::AUTH_RESPONSE_NEGOTIATE
264  * @tc.type: FUNC
265  * @tc.require: AR000GHSJK
266  */
267 HWTEST_F(AuthRequestStateTest, GetStateType_002, testing::ext::TestSize.Level0)
268 {
269     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
270     int32_t ret = authRequestState->GetStateType();
271     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE);
272 }
273 
274 /**
275  * @tc.name: AuthRequestNegotiateState::Enter_001
276  * @tc.desc: 1 set authManager to null
277  *           2 call AuthRequestNegotiateState::Enter with authManager = null
278  *           3 check ret is ERR_DM_FAILED
279  * @tc.type: FUNC
280  * @tc.require: AR000GHSJK
281  */
282 HWTEST_F(AuthRequestStateTest, Enter_003, testing::ext::TestSize.Level0)
283 {
284     std::shared_ptr<DmAuthManager> authManager =
285         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
286     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
287     authRequestState->SetAuthManager(nullptr);
288     int32_t ret = authRequestState->Enter();
289     ASSERT_EQ(ret, ERR_DM_FAILED);
290 }
291 
292 /**
293  * @tc.name: AuthRequestNegotiateState::Enter_004
294  * @tc.desc: 1 set authManager not null
295  *           2 call AuthRequestNegotiateState::Enter with authManager != null
296  *           3 check ret is DM_OK
297  * @tc.type: FUNC
298  * @tc.require: AR000GHSJK
299  */
300 HWTEST_F(AuthRequestStateTest, Enter_004, testing::ext::TestSize.Level0)
301 {
302     std::shared_ptr<DmAuthManager> authManager =
303         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
304     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
305     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
306     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
307     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
308     authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
309     authManager->authRequestContext_->deviceId = "111";
310     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
311     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
312     authManager->timer_ = std::make_shared<DmTimer>();
313     authRequestState->SetAuthManager(authManager);
314     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
315     context->deviceId = "123456";
316     context->sessionId = 22222;
317     authRequestState->SetAuthContext(context);
318     int32_t ret = authRequestState->Enter();
319     ASSERT_EQ(ret, DM_OK);
320 }
321 
322 /**
323  * @tc.name: AuthRequestNegotiateDoneState::GetStateType_003
324  * @tc.desc: 1 call AuthRequestNegotiateDoneState::GetStateType
325  *           2 check ret is AuthState::AUTH_REQUEST_NEGOTIATE_DONE
326  * @tc.type: FUNC
327  * @tc.require: AR000GHSJK
328  */
329 HWTEST_F(AuthRequestStateTest, GetStateType_003, testing::ext::TestSize.Level0)
330 {
331     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
332     int32_t ret = authRequestState->GetStateType();
333     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE_DONE);
334 }
335 
336 /**
337  * @tc.name: AuthRequestNegotiateDoneState::Enter_005
338  * @tc.desc: 1 set authManager to null
339  *           2 call AuthRequestNegotiateDoneState::Enter with authManager = null
340  *           3 check ret is ERR_DM_FAILED
341  * @tc.type: FUNC
342  * @tc.require: AR000GHSJK
343  */
344 HWTEST_F(AuthRequestStateTest, Enter_005, testing::ext::TestSize.Level0)
345 {
346     std::shared_ptr<DmAuthManager> authManager =
347         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
348     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
349     authRequestState->SetAuthManager(nullptr);
350     int32_t ret = authRequestState->Enter();
351     ASSERT_EQ(ret, ERR_DM_FAILED);
352 }
353 
354 /**
355  * @tc.name: AuthRequestNegotiateDoneState::Enter_006
356  * @tc.desc: 1 set authManager not null
357  *           2 call AuthRequestNegotiateDoneState::Enter with authManager != null
358  *           3 check ret is DM_OK
359  * @tc.type: FUNC
360  * @tc.require: AR000GHSJK
361  */
362 HWTEST_F(AuthRequestStateTest, Enter_006, testing::ext::TestSize.Level0)
363 {
364     std::shared_ptr<DmAuthManager> authManager =
365         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
366     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
367     authManager->timer_ = std::make_shared<DmTimer>();
368     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
369     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
370     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
371     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
372     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
373     authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
374     authManager->SetAuthRequestState(authRequestState);
375     authRequestState->SetAuthManager(authManager);
376     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
377     context->sessionId = 333333;
378     authRequestState->SetAuthContext(context);
379     int32_t ret = authRequestState->Enter();
380     ASSERT_EQ(ret, DM_OK);
381 }
382 
383 /**
384  * @tc.name: AuthRequestReplyState::GetStateType_004
385  * @tc.desc: 1 call AuthRequestReplyState::GetStateType
386  *           2 check ret is AuthState::AUTH_REQUEST_REPLY
387  * @tc.type: FUNC
388  * @tc.require: AR000GHSJK
389  */
390 HWTEST_F(AuthRequestStateTest, GetStateType_004, testing::ext::TestSize.Level0)
391 {
392     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
393     int32_t ret = authRequestState->GetStateType();
394     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_REPLY);
395 }
396 
397 /**
398  * @tc.name: AuthRequestReplyState::Enter_007
399  * @tc.desc: 1 set authManager to null
400  *           2 call AuthRequestReplyState::Enter with authManager = null
401  *           3 check ret is ERR_DM_FAILED
402  * @tc.type: FUNC
403  * @tc.require: AR000GHSJK
404  */
405 HWTEST_F(AuthRequestStateTest, Enter_007, testing::ext::TestSize.Level0)
406 {
407     std::shared_ptr<DmAuthManager> authManager =
408         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
409     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
410     authRequestState->SetAuthManager(nullptr);
411     int32_t ret = authRequestState->Enter();
412     ASSERT_EQ(ret, ERR_DM_FAILED);
413 }
414 
415 /**
416  * @tc.name: AuthRequestReplyState::Enter_008
417  * @tc.desc: 1 set authManager not null
418  *           2 call AuthRequestReplyState::Enter with authManager != null
419  *           3 check ret is DM_OK
420  * @tc.type: FUNC
421  * @tc.require: AR000GHSJK
422  */
423 HWTEST_F(AuthRequestStateTest, Enter_008, testing::ext::TestSize.Level0)
424 {
425     std::shared_ptr<DmAuthManager> authManager =
426         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
427     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
428     authManager->timer_ = std::make_shared<DmTimer>();
429     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
430     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
431     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
432     authManager->authRequestState_ = std::make_shared<AuthRequestReplyState>();
433     authManager->authResponseContext_->sessionId = 1;
434     authManager->authPtr_ = authManager->authenticationMap_[1];
435     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
436     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
437     authManager->SetAuthRequestState(authRequestState);
438     authRequestState->SetAuthManager(authManager);
439     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
440     context->sessionId = 333333;
441     authRequestState->SetAuthContext(context);
442     int32_t ret = authRequestState->Enter();
443     ASSERT_EQ(ret, DM_OK);
444 }
445 
446 /**
447  * @tc.name: AuthRequestJoinState::GetStateType_006
448  * @tc.desc: 1 call AuthRequestJoinState::GetStateType
449  *           2 check ret is AuthState::AUTH_REQUEST_JOIN
450  * @tc.type: FUNC
451  * @tc.require: AR000GHSJK
452  */
453 HWTEST_F(AuthRequestStateTest, GetStateType_006, testing::ext::TestSize.Level0)
454 {
455     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
456     int32_t ret = authRequestState->GetStateType();
457     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_JOIN);
458 }
459 
460 /**
461  * @tc.name: AuthRequestJoinState::Enter_011
462  * @tc.desc: 1 set authManager to null
463  *           2 call AuthRequestJoinState::Enter with authManager = null
464  *           3 check ret is ERR_DM_FAILED
465  * @tc.type: FUNC
466  * @tc.require: AR000GHSJK
467  */
468 HWTEST_F(AuthRequestStateTest, Enter_011, testing::ext::TestSize.Level0)
469 {
470     std::shared_ptr<DmAuthManager> authManager =
471         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
472     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
473     authRequestState->SetAuthManager(nullptr);
474     int32_t ret = authRequestState->Enter();
475     ASSERT_EQ(ret, ERR_DM_FAILED);
476 }
477 
478 /**
479  * @tc.name: AuthRequestJoinState::Enter_012
480  * @tc.desc: 1 set authManager not null
481  *           2 call AuthRequestJoinState::Enter with authManager != null
482  *           3 check ret is DM_OK
483  * @tc.type: FUNC
484  * @tc.require: AR000GHSJK
485  */
486 HWTEST_F(AuthRequestStateTest, Enter_012, testing::ext::TestSize.Level0)
487 {
488     std::shared_ptr<DmAuthManager> authManager =
489         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
490     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
491     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
492     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
493     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
494     authManager->authPtr_ = authManager->authenticationMap_[1];
495     authManager->authResponseContext_->groupId = "111";
496     authManager->authResponseContext_->groupName = "222";
497     authManager->authResponseContext_->code = 123;
498     authManager->authResponseContext_->requestId = 234;
499     authManager->authResponseContext_->deviceId = "234";
500     authRequestState->SetAuthManager(authManager);
501     authManager->timer_ = std::make_shared<DmTimer>();
502     authManager->SetAuthRequestState(authRequestState);
503     authManager->hiChainConnector_->RegisterHiChainCallback(authManager);
504     authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
505     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
506     context->deviceId = "44444";
507     context->sessionId = 55555;
508     authRequestState->SetAuthContext(context);
509     int32_t ret = authRequestState->Enter();
510     ASSERT_EQ(ret, DM_OK);
511 }
512 
513 /**
514  * @tc.name: AuthRequestNetworkState::GetStateType_007
515  * @tc.desc: 1 call AuthRequestNetworkState::GetStateType
516  *           2 check ret is AuthState::AUTH_REQUEST_NETWORK
517  * @tc.type: FUNC
518  * @tc.require: AR000GHSJK
519  */
520 HWTEST_F(AuthRequestStateTest, GetStateType_007, testing::ext::TestSize.Level0)
521 {
522     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
523     int32_t ret = authRequestState->GetStateType();
524     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NETWORK);
525 }
526 
527 /**
528  * @tc.name: AuthRequestNetworkState::Enter_013
529  * @tc.desc: 1 set authManager to null
530  *           2 call AuthRequestNetworkState::Enter with authManager = null
531  *           3 check ret is ERR_DM_FAILED
532  * @tc.type: FUNC
533  * @tc.require: AR000GHSJK
534  */
535 HWTEST_F(AuthRequestStateTest, Enter_013, testing::ext::TestSize.Level0)
536 {
537     std::shared_ptr<DmAuthManager> authManager =
538         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
539     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
540     authRequestState->SetAuthManager(nullptr);
541     int32_t ret = authRequestState->Enter();
542     ASSERT_EQ(ret, ERR_DM_FAILED);
543 }
544 
545 /**
546  * @tc.name: AuthRequestNetworkState::Enter_014
547  * @tc.desc: 1 set authManager not null
548  *           2 call AuthRequestNetworkState::Enter with authManager != null
549  *           3 check ret is DM_OK
550  * @tc.type: FUNC
551  * @tc.require: AR000GHSJK
552  */
553 HWTEST_F(AuthRequestStateTest, Enter_014, testing::ext::TestSize.Level0)
554 {
555     std::shared_ptr<DmAuthManager> authManager =
556         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
557     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
558     authManager->timer_ = std::make_shared<DmTimer>();
559     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
560     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
561     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
562     authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
563     authManager->authPtr_ = authManager->authenticationMap_[1];
564     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
565     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
566     authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
567     authManager->SetAuthRequestState(authRequestState);
568     authRequestState->SetAuthManager(authManager);
569     int32_t ret = authRequestState->Enter();
570     ASSERT_EQ(ret, DM_OK);
571 }
572 
573 /**
574  * @tc.name: AuthRequestFinishState::GetStateType_008
575  * @tc.desc: 1 call AuthRequestFinishState::GetStateType
576  *           2 check ret is AuthState::AUTH_REQUEST_FINISH
577  * @tc.type: FUNC
578  * @tc.require: AR000GHSJK
579  */
580 HWTEST_F(AuthRequestStateTest, GetStateType_008, testing::ext::TestSize.Level0)
581 {
582     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
583     int32_t ret = authRequestState->GetStateType();
584     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_FINISH);
585 }
586 
587 /**
588  * @tc.name: AuthRequestFinishState::Enter_015
589  * @tc.desc: 1 set authManager to null
590  *           2 call AuthRequestFinishState::Enter with authManager = null
591  *           3 check ret is ERR_DM_FAILED
592  * @tc.type: FUNC
593  * @tc.require: AR000GHSJK
594  */
595 HWTEST_F(AuthRequestStateTest, Enter_015, testing::ext::TestSize.Level0)
596 {
597     std::shared_ptr<DmAuthManager> authManager =
598         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
599     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
600     authRequestState->SetAuthManager(nullptr);
601     int32_t ret = authRequestState->Enter();
602     ASSERT_EQ(ret, ERR_DM_FAILED);
603 }
604 
605 /**
606  * @tc.name: AuthRequestFinishState::Enter_016
607  * @tc.desc: 1 set authManager not null
608  *           2 call AuthRequestNetworkState::Enter with authManager != null
609  *           3 check ret is DM_OK
610  * @tc.type: FUNC
611  * @tc.require: AR000GHSJK
612  */
613 HWTEST_F(AuthRequestStateTest, Enter_016, testing::ext::TestSize.Level0)
614 {
615     std::shared_ptr<DmAuthManager> authManager =
616         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
617     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
618     authManager->timer_ = std::make_shared<DmTimer>();
619     authManager->authPtr_ = authManager->authenticationMap_[1];
620     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
621     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
622     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
623     authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
624     authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
625     authManager->authResponseContext_->sessionId = 1;
626     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
627     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
628     authManager->SetAuthRequestState(authRequestState);
629     authRequestState->SetAuthManager(authManager);
630     std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
631     context->sessionId = 333333;
632     authRequestState->SetAuthContext(context);
633     int32_t ret = authRequestState->Enter();
634     ASSERT_EQ(ret, DM_OK);
635 }
636 
637 /**
638  * @tc.name: AuthRequestCredential::GetStateType_005
639  * @tc.desc: 1 call AuthRequestCredential::GetStateType
640  *           2 check ret is AuthState::AUTH_REQUEST_CREDENTIAL
641  * @tc.type: FUNC
642  * @tc.require: AR000GHSJK
643  */
644 HWTEST_F(AuthRequestStateTest, GetStateType_005, testing::ext::TestSize.Level0)
645 {
646     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestCredential>();
647     int32_t ret = authRequestState->GetStateType();
648     ASSERT_EQ(ret, AuthState::AUTH_REQUEST_CREDENTIAL);
649 }
650 
651 /**
652  * @tc.name: AuthRequestCredential::Enter_009
653  * @tc.desc: 1 call AuthRequestCredential::Enter
654  *           2 check ret is ERR_DM_FAILED
655  * @tc.type: FUNC
656  * @tc.require: AR000GHSJK
657  */
658 HWTEST_F(AuthRequestStateTest, Enter_009, testing::ext::TestSize.Level0)
659 {
660     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestCredential>();
661     int32_t ret = authRequestState->Enter();
662     ASSERT_EQ(ret, ERR_DM_FAILED);
663 }
664 
665 /**
666  * @tc.name: AuthRequestCredentialDone::GetStateType_009
667  * @tc.desc: 1 call AuthRequestCredentialDone::GetStateType
668  *           2 check ret is AUTH_REQUEST_CREDENTIAL_DONE
669  * @tc.type: FUNC
670  * @tc.require: AR000GHSJK
671  */
672 HWTEST_F(AuthRequestStateTest, GetStateType_009, testing::ext::TestSize.Level0)
673 {
674     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestCredentialDone>();
675     int32_t ret = authRequestState->GetStateType();
676     ASSERT_EQ(ret, AUTH_REQUEST_CREDENTIAL_DONE);
677 }
678 
679 /**
680  * @tc.name: AuthRequestCredentialDone::Enter_010
681  * @tc.desc: 1 call AuthRequestCredentialDone::Enter
682  *           2 check ret is ERR_DM_FAILED
683  * @tc.type: FUNC
684  * @tc.require: AR000GHSJK
685  */
686 HWTEST_F(AuthRequestStateTest, Enter_010, testing::ext::TestSize.Level0)
687 {
688     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestCredentialDone>();
689     int32_t ret = authRequestState->Enter();
690     ASSERT_EQ(ret, ERR_DM_FAILED);
691 }
692 
693 /**
694  * @tc.name: AuthRequestDeleteInit::GetStateType_010
695  * @tc.desc: 1 call AuthRequestDeleteInit::GetStateType
696  *           2 check ret is AUTH_REQUEST_DELETE_INIT
697  * @tc.type: FUNC
698  * @tc.require: AR000GHSJK
699  */
700 HWTEST_F(AuthRequestStateTest, GetStateType_010, testing::ext::TestSize.Level0)
701 {
702     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestDeleteInit>();
703     int32_t ret = authRequestState->GetStateType();
704     ASSERT_EQ(ret, AUTH_REQUEST_DELETE_INIT);
705 }
706 
707 /**
708  * @tc.name: AuthRequestDeleteInit::Enter_017
709  * @tc.desc: 1 call AuthRequestDeleteInit::Enter
710  *           2 check ret is ERR_DM_FAILED
711  * @tc.type: FUNC
712  * @tc.require: AR000GHSJK
713  */
714 HWTEST_F(AuthRequestStateTest, Enter_017, testing::ext::TestSize.Level0)
715 {
716     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestDeleteInit>();
717     int32_t ret = authRequestState->Enter();
718     ASSERT_EQ(ret, ERR_DM_FAILED);
719 }
720 
721 /**
722  * @tc.name: AuthRequestSyncDeleteAcl::GetStateType_011
723  * @tc.desc: 1 call AuthRequestSyncDeleteAcl::GetStateType
724  *           2 check ret is AUTH_REQUEST_SYNCDELETE
725  * @tc.type: FUNC
726  * @tc.require: AR000GHSJK
727  */
728 HWTEST_F(AuthRequestStateTest, GetStateType_011, testing::ext::TestSize.Level0)
729 {
730     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestSyncDeleteAcl>();
731     int32_t ret = authRequestState->GetStateType();
732     ASSERT_EQ(ret, AUTH_REQUEST_SYNCDELETE);
733 }
734 
735 /**
736  * @tc.name: AuthRequestSyncDeleteAcl::Enter_018
737  * @tc.desc: 1 call AuthRequestSyncDeleteAcl::Enter
738  *           2 check ret is ERR_DM_FAILED
739  * @tc.type: FUNC
740  * @tc.require: AR000GHSJK
741  */
742 HWTEST_F(AuthRequestStateTest, Enter_018, testing::ext::TestSize.Level0)
743 {
744     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestSyncDeleteAcl>();
745     int32_t ret = authRequestState->Enter();
746     ASSERT_EQ(ret, ERR_DM_FAILED);
747 }
748 
749 /**
750  * @tc.name: AuthRequestSyncDeleteAclNone::GetStateType_012
751  * @tc.desc: 1 call AuthRequestSyncDeleteAclNone::GetStateType
752  *           2 check ret is AUTH_REQUEST_SYNCDELETE_DONE
753  * @tc.type: FUNC
754  * @tc.require: AR000GHSJK
755  */
756 HWTEST_F(AuthRequestStateTest, GetStateType_012, testing::ext::TestSize.Level0)
757 {
758     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestSyncDeleteAclNone>();
759     int32_t ret = authRequestState->GetStateType();
760     ASSERT_EQ(ret, AUTH_REQUEST_SYNCDELETE_DONE);
761 }
762 
763 /**
764  * @tc.name: AuthRequestSyncDeleteAclNone::Enter_019
765  * @tc.desc: 1 call AuthRequestSyncDeleteAclNone::Enter
766  *           2 check ret is ERR_DM_FAILED
767  * @tc.type: FUNC
768  * @tc.require: AR000GHSJK
769  */
770 HWTEST_F(AuthRequestStateTest, Enter_019, testing::ext::TestSize.Level0)
771 {
772     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestSyncDeleteAclNone>();
773     int32_t ret = authRequestState->Enter();
774     ASSERT_EQ(ret, ERR_DM_FAILED);
775 }
776 } // namespace
777 } // namespace DistributedHardware
778 } // namespace OHOS
779