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