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 23namespace OHOS { 24namespace DistributedHardware { 25void AuthRequestStateTest::SetUp() 26{ 27} 28void AuthRequestStateTest::TearDown() 29{ 30} 31void AuthRequestStateTest::SetUpTestCase() 32{ 33} 34void AuthRequestStateTest::TearDownTestCase() 35{ 36} 37 38namespace { 39std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>(); 40std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>(); 41std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>(); 42std::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 */ 52HWTEST_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 */ 69HWTEST_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 */ 89HWTEST_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 */ 106HWTEST_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 */ 126HWTEST_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 */ 145HWTEST_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 */ 162HWTEST_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 */ 181HWTEST_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 */ 210HWTEST_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 */ 225HWTEST_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 */ 244HWTEST_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 */ 267HWTEST_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 */ 282HWTEST_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 */ 300HWTEST_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 */ 329HWTEST_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 */ 344HWTEST_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 */ 362HWTEST_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 */ 390HWTEST_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 */ 405HWTEST_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 */ 423HWTEST_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 */ 453HWTEST_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 */ 468HWTEST_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 */ 486HWTEST_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 */ 520HWTEST_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 */ 535HWTEST_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 */ 553HWTEST_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 */ 580HWTEST_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 */ 595HWTEST_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 */ 613HWTEST_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 */ 644HWTEST_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 */ 658HWTEST_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 */ 672HWTEST_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 */ 686HWTEST_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} // namespace 693} // namespace DistributedHardware 694} // namespace OHOS 695