1 /*
2 * Copyright (c) 2025 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 "dm_auth_state.h"
17 #include "UTTest_auth_credential_state.h"
18 #include "dm_auth_message_processor_mock.h"
19 #include "device_manager_service_listener.h"
20
21 using namespace testing;
22
23 namespace OHOS {
24 namespace DistributedHardware {
25
26 constexpr const char *TEST_NONE_EMPTY_STRING = "test";
27
SetUpTestCase()28 void AuthCredentialStateTest::SetUpTestCase()
29 {
30 LOGI("AuthCredentialStateTest::SetUpTestCase start.");
31 DmHiChainAuthConnector::dmHiChainAuthConnector = dmHiChainAuthConnectorMock;
32 DmSoftbusSession::dmSoftbusSession = dmSoftbusSessionMock;
33 DmAuthStateMachineMock::dmAuthStateMachineMock = dmAuthStateMachineMock;
34 DmAuthMessageProcessorMock::dmAuthMessageProcessorMock = std::make_shared<DmAuthMessageProcessorMock>();
35 }
36
TearDownTestCase()37 void AuthCredentialStateTest::TearDownTestCase()
38 {
39 LOGI("AuthCredentialStateTest::TearDownTestCase start.");
40 DmHiChainAuthConnector::dmHiChainAuthConnector = nullptr;
41 dmHiChainAuthConnectorMock = nullptr;
42 DmSoftbusSession::dmSoftbusSession = nullptr;
43 dmSoftbusSessionMock = nullptr;
44 DmAuthStateMachineMock::dmAuthStateMachineMock = nullptr;
45 dmAuthStateMachineMock = nullptr;
46 DmAuthMessageProcessorMock::dmAuthMessageProcessorMock = nullptr;
47 }
48
SetUp()49 void AuthCredentialStateTest::SetUp()
50 {
51 LOGI("AuthCredentialStateTest::SetUp start.");
52 softbusConnector = std::make_shared<SoftbusConnector>();
53 listener = std::make_shared<DeviceManagerServiceListener>();
54 hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
55 hiChainConnector = std::make_shared<HiChainConnector>();
56 }
57
TearDown()58 void AuthCredentialStateTest::TearDown()
59 {
60 LOGI("AuthCredentialStateTest::TearDown start.");
61 softbusConnector = nullptr;
62 listener = nullptr;
63 hiChainAuthConnector = nullptr;
64 authManager = nullptr;
65 context = nullptr;
66 Mock::VerifyAndClearExpectations(&*DmHiChainAuthConnector::dmHiChainAuthConnector);
67 Mock::VerifyAndClearExpectations(&*DmSoftbusSession::dmSoftbusSession);
68 Mock::VerifyAndClearExpectations(&*DmAuthStateMachineMock::dmAuthStateMachineMock);
69 Mock::VerifyAndClearExpectations(&*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock);
70 }
71
72 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_001, testing::ext::TestSize.Level1)
73 {
74 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
75 hiChainAuthConnector);
76 context = authManager->GetAuthContext();
77 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
78 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_CREDENTIAL_EXCHANGE_STATE);
79 }
80
81 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_002, testing::ext::TestSize.Level1)
82 {
83 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
84 hiChainAuthConnector);
85 context = authManager->GetAuthContext();
86 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
87 context->isOnline = false;
88
89 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _)).WillRepeatedly(Return(DM_OK));
90
91 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _)).WillRepeatedly(Return(DM_OK));
92
93 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
94 }
95
96 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_003, testing::ext::TestSize.Level1)
97 {
98 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
99 hiChainAuthConnector);
100 context = authManager->GetAuthContext();
101 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
102 context->direction == DM_AUTH_SOURCE;
103 context->accesser.isAuthed = false;
104 context->needAgreeCredential = true;
105
106 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
107 .WillOnce(Return(ERR_DM_FAILED));
108
109 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
110 }
111
112 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_004, testing::ext::TestSize.Level1)
113 {
114 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
115 hiChainAuthConnector);
116 context = authManager->GetAuthContext();
117 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
118 context->direction == DM_AUTH_SOURCE;
119 context->accesser.isAuthed = false;
120 context->needAgreeCredential = true;
121
122 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
123 .WillOnce(Return(DM_OK));
124
125 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
126 .WillOnce(Return(ERR_DM_FAILED));
127
128 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
129 }
130
131 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_005, testing::ext::TestSize.Level1)
132 {
133 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
134 hiChainAuthConnector);
135 context = authManager->GetAuthContext();
136 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
137 context->direction == DM_AUTH_SOURCE;
138 context->accesser.isAuthed = false;
139 context->needAgreeCredential = true;
140
141 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
142 .WillOnce(Return(ERR_DM_FAILED));
143
144 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
145 }
146
147 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_006, testing::ext::TestSize.Level1)
148 {
149 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
150 hiChainAuthConnector);
151 context = authManager->GetAuthContext();
152 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
153 context->direction == DM_AUTH_SOURCE;
154 context->accesser.isAuthed = false;
155 context->needAgreeCredential = true;
156
157 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
158 .WillOnce(Return(DM_OK));
159
160 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
161 .WillOnce(Return(ERR_DM_FAILED));
162
163 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
164 }
165
166 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialExchangeState_007, testing::ext::TestSize.Level1)
167 {
168 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
169 hiChainAuthConnector);
170 context = authManager->GetAuthContext();
171 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialExchangeState>();
172 context->isOnline = false;
173
174 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
175 .WillOnce(Return(DM_OK));
176
177 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
178 .WillOnce(Return(DM_OK));
179
180 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
181 }
182
183 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_001, testing::ext::TestSize.Level1)
184 {
185 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
186 hiChainAuthConnector);
187 context = authManager->GetAuthContext();
188 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
189 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_CREDENTIAL_EXCHANGE_STATE);
190 }
191
192 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_002, testing::ext::TestSize.Level1)
193 {
194 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
195 hiChainAuthConnector);
196 context = authManager->GetAuthContext();
197 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
198
199 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
200 .WillOnce(Return(DM_OK));
201
202 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
203 .WillOnce(Return(DM_OK));
204
205 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
206 .WillOnce(Return(DM_OK));
207
208
209 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
210 }
211
212 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_003, testing::ext::TestSize.Level1)
213 {
214 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
215 hiChainAuthConnector);
216 context = authManager->GetAuthContext();
217 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
218
219 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
220 .WillOnce(Return(ERR_DM_FAILED));
221
222 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
223 }
224
225 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_004, testing::ext::TestSize.Level1)
226 {
227 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
228 hiChainAuthConnector);
229 context = authManager->GetAuthContext();
230 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
231
232 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
233 .WillOnce(Return(ERR_DM_FAILED));
234
235 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
236 }
237
238 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_005, testing::ext::TestSize.Level1)
239 {
240 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
241 hiChainAuthConnector);
242 context = authManager->GetAuthContext();
243 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
244 context->isOnline = false;
245
246 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
247 .WillOnce(Return(DM_OK));
248
249 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
250 .WillOnce(Return(ERR_DM_FAILED));
251
252 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
253 }
254
255 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_006, testing::ext::TestSize.Level1)
256 {
257 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
258 hiChainAuthConnector);
259 context = authManager->GetAuthContext();
260 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
261 context->isOnline = false;
262
263 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
264 .WillOnce(Return(DM_OK));
265
266 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
267 .WillOnce(Return(ERR_DM_FAILED));
268
269 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
270 }
271
272 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_007, testing::ext::TestSize.Level1)
273 {
274 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
275 hiChainAuthConnector);
276 context = authManager->GetAuthContext();
277 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
278 context->isOnline = false;
279
280 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
281 .WillOnce(Return(DM_OK));
282
283 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
284 .WillOnce(Return(DM_OK));
285
286 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
287 .WillOnce(Return(ERR_DM_FAILED));
288
289 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
290 }
291
292 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_008, testing::ext::TestSize.Level1)
293 {
294 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
295 hiChainAuthConnector);
296 context = authManager->GetAuthContext();
297 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
298
299 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
300 .WillOnce(Return(DM_OK));
301
302 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
303 .WillOnce(Return(DM_OK));
304
305 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
306 .WillOnce(Return(ERR_DM_FAILED));
307
308 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
309 }
310
311 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialExchangeState_009, testing::ext::TestSize.Level1)
312 {
313 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
314 hiChainAuthConnector);
315 context = authManager->GetAuthContext();
316 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialExchangeState>();
317
318 EXPECT_CALL(*dmHiChainAuthConnectorMock, AddCredential(_, _, _))
319 .WillOnce(Return(DM_OK));
320
321 EXPECT_CALL(*dmHiChainAuthConnectorMock, ExportCredential(_, _, _))
322 .WillOnce(Return(DM_OK));
323
324 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
325 .WillOnce(Return(DM_OK));
326
327 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
328 }
329
330 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_001, testing::ext::TestSize.Level1)
331 {
332 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
333 hiChainAuthConnector);
334 context = authManager->GetAuthContext();
335 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
336 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_CREDENTIAL_AUTH_START_STATE);
337 }
338
339 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_002, testing::ext::TestSize.Level1)
340 {
341 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
342 hiChainAuthConnector);
343 context = authManager->GetAuthContext();
344 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
345 context->direction == DM_AUTH_SOURCE;
346 context->accesser.isAuthed = false;
347 context->needAgreeCredential = true;
348
349 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
350 .WillOnce(Return(DM_OK));
351 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
352 }
353
354 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_003, testing::ext::TestSize.Level1)
355 {
356 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
357 hiChainAuthConnector);
358 context = authManager->GetAuthContext();
359 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
360 context->direction == DM_AUTH_SOURCE;
361 context->accesser.isAuthed = false;
362 context->needAgreeCredential = true;
363
364 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
365 .WillOnce(Return(ERR_DM_FAILED));
366
367 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
368 }
369
370 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_005, testing::ext::TestSize.Level1)
371 {
372 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
373 hiChainAuthConnector);
374 context = authManager->GetAuthContext();
375 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
376 context->direction == DM_AUTH_SOURCE;
377 context->accesser.isAuthed = false;
378 context->needAgreeCredential = true;
379
380 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
381 .WillOnce(Return(ERR_DM_FAILED));
382
383 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
384 }
385
386 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_006, testing::ext::TestSize.Level1)
387 {
388 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
389 hiChainAuthConnector);
390 context = authManager->GetAuthContext();
391 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
392 context->direction == DM_AUTH_SOURCE;
393 context->accesser.isAuthed = false;
394 context->needAgreeCredential = true;
395
396 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
397 .WillOnce(Return(DM_OK));
398
399 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
400 }
401
402 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_007, testing::ext::TestSize.Level1)
403 {
404 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
405 hiChainAuthConnector);
406 context = authManager->GetAuthContext();
407 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
408 context->direction == DM_AUTH_SOURCE;
409 context->accesser.isAuthed = false;
410 context->needAgreeCredential = true;
411
412 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
413 .WillOnce(Return(DM_OK));
414
415 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
416 }
417
418 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthStartState_008, testing::ext::TestSize.Level1)
419 {
420 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
421 hiChainAuthConnector);
422 context = authManager->GetAuthContext();
423 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthStartState>();
424 context->direction == DM_AUTH_SOURCE;
425 context->accesser.isAuthed = false;
426 context->needAgreeCredential = true;
427
428 EXPECT_CALL(*dmHiChainAuthConnectorMock, AgreeCredential(_, _, _, _))
429 .WillOnce(Return(DM_OK));
430
431 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
432 }
433
434 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthStartState_001, testing::ext::TestSize.Level1)
435 {
436 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
437 hiChainAuthConnector);
438 context = authManager->GetAuthContext();
439 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthStartState>();
440 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_CREDENTIAL_AUTH_START_STATE);
441 }
442
443 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthStartState_002, testing::ext::TestSize.Level1)
444 {
445 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
446 hiChainAuthConnector);
447 context = authManager->GetAuthContext();
448 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthStartState>();
449 context->transmitData = "test";
450
451 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
452
453 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_)).WillOnce(Return(ON_TRANSMIT));
454
455 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
456 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
457
458 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
459
460 EXPECT_EQ(authState->Action(context), DM_OK);
461 }
462
463 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthStartState_003, testing::ext::TestSize.Level1)
464 {
465 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
466 hiChainAuthConnector);
467 context = authManager->GetAuthContext();
468 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthStartState>();
469 context->transmitData = "test";
470
471 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(ERR_DM_FAILED));
472
473 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
474 }
475
476 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthStartState_004, testing::ext::TestSize.Level1)
477 {
478 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
479 hiChainAuthConnector);
480 context = authManager->GetAuthContext();
481 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthStartState>();
482 context->transmitData = "test";
483
484 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
485
486 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_)).WillOnce(Return(ON_ERROR));
487
488 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
489 }
490
491 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthStartState_005, testing::ext::TestSize.Level1)
492 {
493 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
494 hiChainAuthConnector);
495 context = authManager->GetAuthContext();
496 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthStartState>();
497 context->transmitData = "test";
498
499 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
500
501 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_)).WillOnce(Return(ON_TRANSMIT));
502
503 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
504 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
505
506 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(ERR_DM_FAILED));
507
508 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
509 }
510
511 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthNegotiateState_001, testing::ext::TestSize.Level1)
512 {
513 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
514 hiChainAuthConnector);
515 context = authManager->GetAuthContext();
516 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthNegotiateState>();
517 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_CREDENTIAL_AUTH_NEGOTIATE_STATE);
518 }
519
520 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthNegotiateState_002, testing::ext::TestSize.Level1)
521 {
522 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
523 hiChainAuthConnector);
524 context = authManager->GetAuthContext();
525 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthNegotiateState>();
526 context->transmitData = "test";
527
528 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
529
530 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_)).WillOnce(Return(ON_TRANSMIT));
531
532 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
533 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
534
535 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
536
537 EXPECT_EQ(authState->Action(context), DM_OK);
538 }
539
540 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthNegotiateState_003, testing::ext::TestSize.Level1)
541 {
542 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
543 hiChainAuthConnector);
544 context = authManager->GetAuthContext();
545 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthNegotiateState>();
546 context->transmitData = "test";
547
548 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(ERR_DM_FAILED));
549
550 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
551 }
552
553 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthNegotiateState_004, testing::ext::TestSize.Level1)
554 {
555 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
556 hiChainAuthConnector);
557 context = authManager->GetAuthContext();
558 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthNegotiateState>();
559 context->transmitData = "test";
560
561 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
562
563 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_)).WillOnce(Return(ON_ERROR));
564
565 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
566 }
567
568 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthNegotiateState_005, testing::ext::TestSize.Level1)
569 {
570 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
571 hiChainAuthConnector);
572 context = authManager->GetAuthContext();
573 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthNegotiateState>();
574 context->transmitData = "test";
575
576 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
577
578 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_)).WillOnce(Return(ON_TRANSMIT));
579
580 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
581 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
582
583 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(ERR_DM_FAILED));
584
585 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
586 }
587
588 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_001, testing::ext::TestSize.Level1)
589 {
590 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
591 hiChainAuthConnector);
592 context = authManager->GetAuthContext();
593 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
594 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_CREDENTIAL_AUTH_NEGOTIATE_STATE);
595 }
596
597 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_002, testing::ext::TestSize.Level1)
598 {
599 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
600 hiChainAuthConnector);
601 context = authManager->GetAuthContext();
602 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
603 context->transmitData = "test";
604
605 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
606
607 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
608 .WillOnce(Return(ON_TRANSMIT))
609 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
610 .WillOnce(Return(ON_FINISH));
611
612 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
613 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
614
615 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
616
617 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, SaveSessionKeyToDP(_, _))
618 .WillOnce(Return(DM_OK));
619
620 EXPECT_EQ(authState->Action(context), DM_OK);
621 }
622
623 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_003, testing::ext::TestSize.Level1)
624 {
625 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
626 hiChainAuthConnector);
627 context = authManager->GetAuthContext();
628 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
629 context->transmitData = "test";
630
631 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(ERR_DM_FAILED));
632
633 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
634 }
635
636 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_004, testing::ext::TestSize.Level1)
637 {
638 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
639 hiChainAuthConnector);
640 context = authManager->GetAuthContext();
641 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
642 context->transmitData = "test";
643
644 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
645
646 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
647 .WillOnce(Return(ON_ERROR));
648
649 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
650 }
651
652 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_005, testing::ext::TestSize.Level1)
653 {
654 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
655 hiChainAuthConnector);
656 context = authManager->GetAuthContext();
657 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
658 context->transmitData = "test";
659
660 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
661
662 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
663 .WillOnce(Return(ON_TRANSMIT))
664 .WillOnce(Return(ON_ERROR));
665
666 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
667 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
668
669 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
670
671 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
672 }
673
674 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_006, testing::ext::TestSize.Level1)
675 {
676 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
677 hiChainAuthConnector);
678 context = authManager->GetAuthContext();
679 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
680 context->transmitData = "test";
681
682 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
683
684 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
685 .WillOnce(Return(ON_TRANSMIT))
686 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
687 .WillOnce(Return(ON_ERROR));
688 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
689 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
690
691 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
692
693 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
694 }
695
696 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_007, testing::ext::TestSize.Level1)
697 {
698 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
699 hiChainAuthConnector);
700 context = authManager->GetAuthContext();
701 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
702 context->transmitData = "test";
703
704 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
705
706 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
707 .WillOnce(Return(ON_TRANSMIT))
708 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
709 .WillOnce(Return(ON_FINISH));
710
711 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, SaveSessionKeyToDP(_, _))
712 .WillOnce(Return(ERR_DM_FAILED));
713
714 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
715 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
716
717 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
718
719 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
720 }
721
722 HWTEST_F(AuthCredentialStateTest, AuthSinkCredentialAuthNegotiateState_008, testing::ext::TestSize.Level1)
723 {
724 authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
725 hiChainAuthConnector);
726 context = authManager->GetAuthContext();
727 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkCredentialAuthNegotiateState>();
728 context->transmitData = "test";
729
730 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
731
732 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
733 .WillOnce(Return(ON_TRANSMIT));
734
735 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
736 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
737
738 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(ERR_DM_FAILED));
739
740 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
741 }
742
743 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_001, testing::ext::TestSize.Level1)
744 {
745 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
746 hiChainAuthConnector);
747 context = authManager->GetAuthContext();
748 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
749 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_CREDENTIAL_AUTH_DONE_STATE);
750 }
751
752 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_002, testing::ext::TestSize.Level1)
753 {
754 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
755 hiChainAuthConnector);
756 context = authManager->GetAuthContext();
757 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
758 context->transmitData = "test";
759 context->accesser.isGenerateLnnCredential == true;
760 context->isAppCredentialVerified = false;
761
762 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
763
764 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
765 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
766 .WillOnce(Return(ON_FINISH))
767 .WillOnce(Return(ON_TRANSMIT));
768
769 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, SaveSessionKeyToDP(_, _))
770 .WillOnce(Return(DM_OK));
771
772 EXPECT_CALL(*dmHiChainAuthConnectorMock, AuthCredential(_, _, _, _)).WillOnce(Return(DM_OK));
773
774 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
775 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
776
777 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
778
779 EXPECT_EQ(authState->Action(context), DM_OK);
780 }
781
782 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_003, testing::ext::TestSize.Level1)
783 {
784 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
785 hiChainAuthConnector);
786 context = authManager->GetAuthContext();
787 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
788 context->transmitData = "test";
789
790 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(ERR_DM_FAILED));
791
792 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
793 }
794
795 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_004, testing::ext::TestSize.Level1)
796 {
797 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
798 hiChainAuthConnector);
799 context = authManager->GetAuthContext();
800 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
801 context->transmitData = "test";
802
803 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
804
805 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
806 .WillOnce(Return(ON_ERROR));
807
808 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
809 }
810
811 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_005, testing::ext::TestSize.Level1)
812 {
813 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
814 hiChainAuthConnector);
815 context = authManager->GetAuthContext();
816 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
817 context->transmitData = "test";
818
819 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
820
821 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
822 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
823 .WillOnce(Return(ON_ERROR));
824
825 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
826 }
827
828 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_006, testing::ext::TestSize.Level1)
829 {
830 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
831 hiChainAuthConnector);
832 context = authManager->GetAuthContext();
833 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
834 context->transmitData = "test";
835
836 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
837
838 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
839 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
840 .WillOnce(Return(ON_FINISH))
841 .WillOnce(Return(ON_ERROR));
842
843 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
844 }
845
846 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_007, testing::ext::TestSize.Level1)
847 {
848 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
849 hiChainAuthConnector);
850 context = authManager->GetAuthContext();
851 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
852 context->transmitData = "test";
853
854 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
855
856 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
857 }
858
859 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_008, testing::ext::TestSize.Level1)
860 {
861 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
862 hiChainAuthConnector);
863 context = authManager->GetAuthContext();
864 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
865 context->transmitData = "test";
866
867 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
868
869 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
870 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
871 .WillOnce(Return(ON_FINISH));
872
873 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, SaveSessionKeyToDP(_, _))
874 .WillOnce(Return(DM_OK));
875
876 EXPECT_CALL(*dmHiChainAuthConnectorMock, AuthCredential(_, _, _, _)).WillOnce(Return(ERR_DM_FAILED));
877
878 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
879 }
880
881 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_009, testing::ext::TestSize.Level1)
882 {
883 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
884 hiChainAuthConnector);
885 context = authManager->GetAuthContext();
886 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
887 context->transmitData = "test";
888
889 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
890
891 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
892 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
893 .WillOnce(Return(ON_FINISH))
894 .WillOnce(Return(ON_TRANSMIT));
895
896 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, SaveSessionKeyToDP(_, _))
897 .WillOnce(Return(DM_OK));
898
899 EXPECT_CALL(*dmHiChainAuthConnectorMock, AuthCredential(_, _, _, _)).WillOnce(Return(DM_OK));
900
901 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
902 .WillOnce(Return(""));
903
904 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
905 }
906
907 HWTEST_F(AuthCredentialStateTest, AuthSrcCredentialAuthDoneState_0010, testing::ext::TestSize.Level1)
908 {
909 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
910 hiChainAuthConnector);
911 context = authManager->GetAuthContext();
912 std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcCredentialAuthDoneState>();
913 context->transmitData = "test";
914
915 EXPECT_CALL(*dmHiChainAuthConnectorMock, ProcessCredData(_, _)).WillOnce(Return(DM_OK));
916
917 EXPECT_CALL(*dmAuthStateMachineMock, WaitExpectEvent(_))
918 .WillOnce(Return(ON_SESSION_KEY_RETURNED))
919 .WillOnce(Return(ON_FINISH))
920 .WillOnce(Return(ON_TRANSMIT));
921
922 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, SaveSessionKeyToDP(_, _))
923 .WillOnce(Return(DM_OK));
924
925 EXPECT_CALL(*dmHiChainAuthConnectorMock, AuthCredential(_, _, _, _)).WillOnce(Return(DM_OK));
926
927 EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
928 .WillOnce(Return(TEST_NONE_EMPTY_STRING));
929
930 EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(ERR_DM_FAILED));
931
932 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
933 }
934
935 }
936 }
937