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_response_state.h"
17
18 #include "auth_message_processor.h"
19 #include "auth_response_state.h"
20 #include "dm_auth_manager.h"
21 #include "dm_constants.h"
22 #include "dm_log.h"
23 #include "device_manager_service_listener.h"
24
25 namespace OHOS {
26 namespace DistributedHardware {
SetUp()27 void AuthResponseStateTest::SetUp()
28 {
29 }
TearDown()30 void AuthResponseStateTest::TearDown()
31 {
32 }
SetUpTestCase()33 void AuthResponseStateTest::SetUpTestCase()
34 {
35 }
TearDownTestCase()36 void AuthResponseStateTest::TearDownTestCase()
37 {
38 }
39
40 namespace {
41 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
42 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
43 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
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(AuthResponseStateTest, Leave_001, testing::ext::TestSize.Level0)
53 {
54 std::shared_ptr<DmAuthManager> authManager =
55 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
56 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
57 int32_t ret = authResponseState->Leave();
58 ASSERT_EQ(ret, DM_OK);
59 }
60
61 /**
62 * @tc.name: AuthRequestInitState::GetAuthContext_001
63 * @tc.desc: 1 set authManager not null
64 * 2 call AuthRequestInitState::GetAuthContext with authManager ！= null
65 * 3 check ret is authResponseState->authManager_.use_count()
66 * @tc.type: FUNC
67 * @tc.require: AR000GHSJK
68 */
69 HWTEST_F(AuthResponseStateTest, GetAuthContext_001, testing::ext::TestSize.Level0)
70 {
71 std::shared_ptr<DmAuthManager> authManager =
72 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
73 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
74 std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
75 authResponseState->GetAuthContext();
76 int32_t ret = authResponseState->context_.use_count();
77 authResponseState->context_.reset();
78 ASSERT_EQ(ret, 0);
79 }
80
81 /**
82 * @tc.name: AuthResponseInitState::SetAuthManager_001
83 * @tc.desc: 1 set authManager not null
84 * 2 call AuthResponseInitState::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(AuthResponseStateTest, SetAuthManager_001, testing::ext::TestSize.Level0)
90 {
91 std::shared_ptr<DmAuthManager> authManager =
92 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
93 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
94 authResponseState->SetAuthManager(authManager);
95 int32_t ret = authResponseState->authManager_.use_count();
96 ASSERT_EQ(ret, 1);
97 }
98
99 /**
100 * @tc.name: AuthResponseInitState::SetAuthManager_002
101 * @tc.desc: 1 set authManager to null
102 * 2 call AuthResponseInitState::SetAuthManager with authManager = null
103 * 3 check ret is authResponseState->authManager_.use_count()
104 * @tc.type: FUNC
105 * @tc.require: AR000GHSJK
106 */
107 HWTEST_F(AuthResponseStateTest, SetAuthManager_002, testing::ext::TestSize.Level0)
108 {
109 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
110 authResponseState->SetAuthManager(nullptr);
111 int32_t ret = authResponseState->authManager_.use_count();
112 ASSERT_EQ(ret, 0);
113 }
114
115 /**
116 * @tc.name: AuthResponseInitState::TransitionTo_001
117 * @tc.desc: 1 set authManager to null
118 * 2 call AuthResponseInitState::TransitionTo with authManager = null
119 * 4 check ret is ERR_DM_FAILED
120 * @tc.type: FUNC
121 * @tc.require: AR000GHSJK
122 */
123 HWTEST_F(AuthResponseStateTest, TransitionTo_001, testing::ext::TestSize.Level0)
124 {
125 std::shared_ptr<DmAuthManager> authManager =
126 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
127 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
128 authManager = nullptr;
129 authResponseState->authManager_ = authManager;
130 int32_t ret = authResponseState->TransitionTo(std::make_shared<AuthResponseNegotiateState>());
131 ASSERT_EQ(ret, ERR_DM_FAILED);
132 }
133
134 /**
135 * @tc.name: AuthResponseInitState::TransitionTo_002
136 * @tc.desc: 1 set authManager not null
137 * 2 call AuthResponseInitState::TransitionTo with authManager != null
138 * 4 check ret is DM_OK
139 * @tc.type: FUNC
140 * @tc.require: AR000GHSJK
141 */
142 HWTEST_F(AuthResponseStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
143 {
144 std::shared_ptr<DmAuthManager> authManager =
145 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
146 std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
147 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
148 authManager->authResponseState_ = std::make_shared<AuthResponseInitState>();
149 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
150 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
151 context->sessionId = 123456;
152 authResponseState->SetAuthContext(context);
153 authResponseState->SetAuthManager(authManager);
154 int32_t ret = authResponseState->TransitionTo(std::make_shared<AuthResponseInitState>());
155 ASSERT_EQ(ret, DM_OK);
156 }
157
158 /**
159 * @tc.name: AuthResponseInitState::GetStateType_001
160 * @tc.desc: 1 call AuthResponseInitState::GetStateType
161 * 2 check ret is AuthState::AUTH_RESPONSE_INIT
162 * @tc.type: FUNC
163 * @tc.require: AR000GHSJK
164 */
165 HWTEST_F(AuthResponseStateTest, GetStateType_001, testing::ext::TestSize.Level0)
166 {
167 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
168 int32_t ret = authResponseState->GetStateType();
169 ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_INIT);
170 }
171
172 /**
173 * @tc.name: AuthResponseInitState::Enter_001
174 * @tc.desc: 1 call AuthResponseInitState::GetStateType
175 * 2 check ret is AuthResponseInitState::Enter
176 * @tc.type: FUNC
177 * @tc.require: AR000GHSJK
178 */
179 HWTEST_F(AuthResponseStateTest, Enter_001, testing::ext::TestSize.Level0)
180 {
181 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
182 int32_t ret = authResponseState->Enter();
183 ASSERT_EQ(ret, DM_OK);
184 }
185
186 /**
187 * @tc.name: AuthResponseNegotiateState::GetStateType_002
188 * @tc.desc: 1 call AuthResponseNegotiateState::GetStateType
189 * 2 check ret is AuthState::AUTH_RESPONSE_NEGOTIATE
190 * @tc.type: FUNC
191 * @tc.require: AR000GHSJK
192 */
193 HWTEST_F(AuthResponseStateTest, GetStateType_002, testing::ext::TestSize.Level0)
194 {
195 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
196 int32_t ret = authResponseState->GetStateType();
197 ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_NEGOTIATE);
198 }
199
200 /**
201 * @tc.name: AuthResponseNegotiateState::Enter_002
202 * @tc.desc: 1 set authManager to null
203 * 2 call AuthResponseNegotiateState::Enter with authManager = null
204 * 3 check ret is ERR_DM_FAILED
205 * @tc.type: FUNC
206 * @tc.require: AR000GHSJK
207 */
208 HWTEST_F(AuthResponseStateTest, Enter_002, testing::ext::TestSize.Level0)
209 {
210 std::shared_ptr<DmAuthManager> authManager =
211 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
212 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
213 authManager = nullptr;
214 authResponseState->SetAuthManager(authManager);
215 int32_t ret = authResponseState->Enter();
216 ASSERT_EQ(ret, ERR_DM_FAILED);
217 }
218
219 /**
220 * @tc.name: AuthResponseNegotiateState::Enter_003
221 * @tc.desc: 1 set authManager not null
222 * 2 call AuthResponseNegotiateState::Enter with authManager != null
223 * 3 check ret is DM_OK
224 * @tc.type: FUNC
225 * @tc.require: AR000GHSJK
226 */
227 HWTEST_F(AuthResponseStateTest, Enter_003, testing::ext::TestSize.Level0)
228 {
229 std::shared_ptr<DmAuthManager> authManager =
230 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
231 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
232 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
233 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
234 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
235 authManager->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
236 authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
237 authManager->authResponseContext_->deviceId = "111";
238 authManager->authResponseContext_->localDeviceId = "222";
239 authManager->authPtr_ = authManager->authenticationMap_[1];
240 authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
241 authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
242 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
243 authManager->timer_ = std::make_shared<DmTimer>();
244 authResponseState->SetAuthManager(authManager);
245 std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
246 context->deviceId = "123456";
247 context->sessionId = 22222;
248 authResponseState->SetAuthContext(context);
249 int32_t ret = authResponseState->Enter();
250 ASSERT_EQ(ret, DM_OK);
251 }
252
253 /**
254 * @tc.name: AuthResponseConfirmState::GetStateType_003
255 * @tc.desc: 1 call AuthResponseConfirmState::GetStateType
256 * 2 check ret is AuthState::AUTH_RESPONSE_CONFIRM
257 * @tc.type: FUNC
258 * @tc.require: AR000GHSJK
259 */
260 HWTEST_F(AuthResponseStateTest, GetStateType_003, testing::ext::TestSize.Level0)
261 {
262 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
263 int32_t ret = authResponseState->GetStateType();
264 ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_CONFIRM);
265 }
266
267 /**
268 * @tc.name: AuthResponseConfirmState::Enter_004
269 * @tc.desc: 1 set authManager to null
270 * 2 call AuthResponseConfirmState::Enter with authManager = null
271 * 3 check ret is ERR_DM_FAILED
272 * @tc.type: FUNC
273 * @tc.require: AR000GHSJK
274 */
275 HWTEST_F(AuthResponseStateTest, Enter_004, testing::ext::TestSize.Level0)
276 {
277 std::shared_ptr<DmAuthManager> authManager =
278 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
279 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
280 authResponseState->SetAuthManager(nullptr);
281 int32_t ret = authResponseState->Enter();
282 ASSERT_EQ(ret, ERR_DM_FAILED);
283 }
284
285 /**
286 * @tc.name: AuthResponseConfirmState::Enter_005
287 * @tc.desc: 1 set authManager not null
288 * 2 call AuthResponseConfirmState::Enter with authManager != null
289 * 3 check ret is DM_OK
290 * @tc.type: FUNC
291 * @tc.require: AR000GHSJK
292 */
293 HWTEST_F(AuthResponseStateTest, Enter_005, testing::ext::TestSize.Level0)
294 {
295 std::shared_ptr<DmAuthManager> authManager =
296 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
297 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
298 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
299 authResponseState->SetAuthManager(authManager);
300 int32_t ret = authResponseState->Enter();
301 ASSERT_EQ(ret, DM_OK);
302 }
303
304 /**
305 * @tc.name: AuthResponseGroupState::GetStateType_004
306 * @tc.desc: 1 call AuthResponseGroupState::GetStateType
307 * 2 check ret is AuthState::AUTH_RESPONSE_GROUP
308 * @tc.type: FUNC
309 * @tc.require: AR000GHSJK
310 */
311 HWTEST_F(AuthResponseStateTest, GetStateType_004, testing::ext::TestSize.Level0)
312 {
313 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
314 int32_t ret = authResponseState->GetStateType();
315 ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_GROUP);
316 }
317
318 /**
319 * @tc.name: AuthResponseGroupState::Enter_006
320 * @tc.desc: 1 set authManager to null
321 * 2 call AuthResponseGroupState::Enter with authManager = null
322 * 3 check ret is ERR_DM_FAILED
323 * @tc.type: FUNC
324 * @tc.require: AR000GHSJK
325 */
326 HWTEST_F(AuthResponseStateTest, Enter_006, testing::ext::TestSize.Level0)
327 {
328 std::shared_ptr<DmAuthManager> authManager =
329 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
330 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
331 authResponseState->SetAuthManager(nullptr);
332 int32_t ret = authResponseState->Enter();
333 ASSERT_EQ(ret, ERR_DM_FAILED);
334 }
335
336 /**
337 * @tc.name: AuthResponseGroupState::Enter_007
338 * @tc.desc: 1 set authManager not null
339 * 2 call AuthResponseGroupState::Enter with authManager != null
340 * 3 check ret is DM_OK
341 * @tc.type: FUNC
342 * @tc.require: AR000GHSJK
343 */
344 HWTEST_F(AuthResponseStateTest, Enter_007, testing::ext::TestSize.Level0)
345 {
346 std::shared_ptr<DmAuthManager> authManager =
347 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
348 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
349 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
350 authManager->authResponseState_ = std::make_shared<AuthResponseGroupState>();
351 authResponseState->SetAuthManager(authManager);
352 int32_t ret = authResponseState->Enter();
353 ASSERT_EQ(ret, DM_OK);
354 }
355
356 /**
357 * @tc.name: AuthResponseShowState::GetStateType_005
358 * @tc.desc: 1 call AuthResponseShowState::GetStateType
359 * 2 check ret is AuthState::AUTH_RESPONSE_SHOW
360 * @tc.type: FUNC
361 * @tc.require: AR000GHSJK
362 */
363 HWTEST_F(AuthResponseStateTest, GetStateType_005, testing::ext::TestSize.Level0)
364 {
365 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
366 int32_t ret = authResponseState->GetStateType();
367 ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_SHOW);
368 }
369
370 /**
371 * @tc.name: AuthResponseShowState::Enter_008
372 * @tc.desc: 1 set authManager to null
373 * 2 call AuthResponseShowState::Enter with authManager = null
374 * 3 check ret is ERR_DM_FAILED
375 * @tc.type: FUNC
376 * @tc.require: AR000GHSJK
377 */
378 HWTEST_F(AuthResponseStateTest, Enter_008, testing::ext::TestSize.Level0)
379 {
380 std::shared_ptr<DmAuthManager> authManager =
381 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
382 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
383 authResponseState->SetAuthManager(nullptr);
384 int32_t ret = authResponseState->Enter();
385 ASSERT_EQ(ret, ERR_DM_FAILED);
386 }
387
388 /**
389 * @tc.name: AuthResponseShowState::Enter_009
390 * @tc.desc: 1 set authManager not null
391 * 2 call AuthResponseShowState::Enter with authManager != null
392 * 3 check ret is DM_OK
393 * @tc.type: FUNC
394 * @tc.require: AR000GHSJK
395 */
396 HWTEST_F(AuthResponseStateTest, Enter_009, testing::ext::TestSize.Level0)
397 {
398 std::shared_ptr<DmAuthManager> authManager =
399 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
400 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
401 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
402 authManager->authPtr_ = authManager->authenticationMap_[1];
403 authManager->authResponseContext_->code = 123456;
404 authResponseState->SetAuthManager(authManager);
405 int32_t ret = authResponseState->Enter();
406 ASSERT_EQ(ret, DM_OK);
407 }
408
409 /**
410 * @tc.name: AuthResponseFinishState::GetStateType_006
411 * @tc.desc: 1 call AuthResponseShowState::GetStateType
412 * 2 check ret is AuthState::AUTH_RESPONSE_SHOW
413 * @tc.type: FUNC
414 * @tc.require: AR000GHSJK
415 */
416 HWTEST_F(AuthResponseStateTest, GetStateType_006, testing::ext::TestSize.Level0)
417 {
418 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
419 int32_t ret = authResponseState->GetStateType();
420 ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_FINISH);
421 }
422
423 /**
424 * @tc.name: AuthResponseFinishState::Enter_010
425 * @tc.desc: 1 set authManager to null
426 * 2 call AuthResponseFinishState::Enter with authManager = null
427 * 3 check ret is ERR_DM_FAILED
428 * @tc.type: FUNC
429 * @tc.require: AR000GHSJK
430 */
431 HWTEST_F(AuthResponseStateTest, Enter_010, testing::ext::TestSize.Level0)
432 {
433 std::shared_ptr<DmAuthManager> authManager =
434 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
435 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
436 authResponseState->SetAuthManager(nullptr);
437 int32_t ret = authResponseState->Enter();
438 ASSERT_EQ(ret, ERR_DM_FAILED);
439 }
440
441 /**
442 * @tc.name: AuthResponseFinishState::Enter_011
443 * @tc.desc: 1 set authManager not null
444 * 2 call AuthResponseFinishState::Enter with authManager != null
445 * 3 check ret is DM_OK
446 * @tc.type: FUNC
447 * @tc.require: AR000GHSJK
448 */
449 HWTEST_F(AuthResponseStateTest, Enter_011, testing::ext::TestSize.Level0)
450 {
451 std::shared_ptr<DmAuthManager> authManager =
452 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector);
453 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
454 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
455 authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
456 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
457 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
458 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
459 authManager->listener_ = std::make_shared<DeviceManagerServiceListener>();
460 authManager->authPtr_ = authManager->authenticationMap_[1];
461 authManager->authResponseContext_->sessionId = 1;
462 authManager->authRequestContext_->deviceId = "2";
463 authManager->authRequestContext_->hostPkgName = "3";
464 authManager->authRequestContext_->token = "4";
465 authManager->authResponseContext_->reply = 5;
466 authManager->authRequestContext_->reason = 6;
467 authManager->SetAuthResponseState(authResponseState);
468 authManager->timer_ = std::make_shared<DmTimer>();
469 authResponseState->SetAuthManager(authManager);
470 std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
471 authResponseState->SetAuthContext(context);
472 int32_t ret = authResponseState->Enter();
473 ASSERT_EQ(ret, DM_OK);
474 }
475 } // namespace
476 } // namespace DistributedHardware
477 } // namespace OHOS
478