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 "enroll_context.h"
17
18 #include "mock_context.h"
19 #include "mock_credential_info.h"
20 #include "mock_enrollment.h"
21 #include "mock_schedule_node.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace UserIam {
27 namespace UserAuth {
28 class EnrollContextTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31
32 static void TearDownTestCase();
33
34 void SetUp() override;
35
36 void TearDown() override;
37 };
38
SetUpTestCase()39 void EnrollContextTest::SetUpTestCase()
40 {
41 }
42
TearDownTestCase()43 void EnrollContextTest::TearDownTestCase()
44 {
45 }
46
SetUp()47 void EnrollContextTest::SetUp()
48 {
49 }
50
TearDown()51 void EnrollContextTest::TearDown()
52 {
53 }
54
55 HWTEST_F(EnrollContextTest, EnrollContextTest_NullHdi, TestSize.Level0)
56 {
57 const uint64_t testContestId = 2;
58 const int32_t testResultCode = 7;
59 const auto finalResult = Common::MakeShared<Attributes>();
60 ASSERT_NE(finalResult, nullptr);
61 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
62 ASSERT_NE(contextCallback, nullptr);
63 EXPECT_CALL(*contextCallback, OnResult(_, _)).Times(Exactly(1));
64 // Error: enroll is null
65 std::shared_ptr<Enrollment> enroll = nullptr;
66
67 auto oriContext = Common::MakeShared<EnrollContext>(testContestId, enroll, contextCallback);
68 ASSERT_NE(oriContext, nullptr);
69 std::shared_ptr<Context> context = oriContext;
70 std::shared_ptr<ScheduleNodeCallback> nodeCallback = oriContext;
71
72 ASSERT_EQ(context->Start(), false);
73 ASSERT_EQ(context->Stop(), false);
74 nodeCallback->OnScheduleStoped(testResultCode, finalResult);
75 }
76
77 HWTEST_F(EnrollContextTest, EnrollContextTest_NullCallback, TestSize.Level0)
78 {
79 const uint64_t testContestId = 2;
80 const ExecutorRole testRole = static_cast<ExecutorRole>(3);
81 const int32_t testModuleType = 4;
82 const std::vector<uint8_t> testAcquireMsg = {4, 5, 6};
83 const int32_t testResultCode = 7;
84 const auto finalResult = Common::MakeShared<Attributes>();
85 ASSERT_NE(finalResult, nullptr);
86
87 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
88 ASSERT_NE(mockEnroll, nullptr);
89 // Error: contextCallback is null
90 std::shared_ptr<ContextCallback> contextCallback = nullptr;
91
92 auto oriContext = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
93 ASSERT_NE(oriContext, nullptr);
94 std::shared_ptr<ScheduleNodeCallback> nodeCallback = oriContext;
95
96 nodeCallback->OnScheduleStarted();
97 nodeCallback->OnScheduleProcessed(testRole, testModuleType, testAcquireMsg);
98 nodeCallback->OnScheduleStoped(testResultCode, finalResult);
99 }
100
101 HWTEST_F(EnrollContextTest, EnrollContextTest_BasicInfo, TestSize.Level0)
102 {
103 const uint64_t testContestId = 2;
104
105 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
106 ASSERT_NE(mockEnroll, nullptr);
107 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
108 ASSERT_NE(contextCallback, nullptr);
109
110 auto oriContext = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
111 ASSERT_NE(oriContext, nullptr);
112 std::shared_ptr<Context> context = oriContext;
113
114 ASSERT_EQ(context->GetContextId(), testContestId);
115 ASSERT_EQ(context->GetContextType(), CONTEXT_ENROLL);
116 }
117
118 HWTEST_F(EnrollContextTest, EnrollContextTest_Start_001, TestSize.Level0)
119 {
120 static const uint64_t testContestId = 2;
121
122 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
123 ASSERT_NE(mockEnroll, nullptr);
124 EXPECT_CALL(*mockEnroll, GetLatestError()).Times(1);
125 EXPECT_CALL(*mockEnroll, Start(_, _))
126 .Times(Exactly(1))
127 .WillOnce([](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0102(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 128 std::shared_ptr<ScheduleNodeCallback> callback) {
129 // Error: process enrollment start fail
130 return false;
131 });
132 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
133 ASSERT_NE(contextCallback, nullptr);
134 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
135 ASSERT_NE(context, nullptr);
136 ASSERT_EQ(context->Start(), false);
137 }
138
139 HWTEST_F(EnrollContextTest, EnrollContextTest_Start_002, TestSize.Level0)
140 {
141 static const uint64_t testContestId = 2;
142
143 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
144 ASSERT_NE(mockEnroll, nullptr);
145 EXPECT_CALL(*mockEnroll, Start(_, _))
146 .Times(Exactly(1))
147 .WillOnce([](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0202(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 148 std::shared_ptr<ScheduleNodeCallback> callback) {
149 // Error: scheduleNodeList size = 0
150 return true;
151 });
152 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
153 ASSERT_NE(contextCallback, nullptr);
154 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
155 ASSERT_NE(context, nullptr);
156 ASSERT_EQ(context->Start(), false);
157 }
158
159 HWTEST_F(EnrollContextTest, EnrollContextTest_Start_003, TestSize.Level0)
160 {
161 static const uint64_t testContestId = 2;
162
163 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
164 ASSERT_NE(mockEnroll, nullptr);
165 EXPECT_CALL(*mockEnroll, Start(_, _))
166 .Times(Exactly(1))
167 .WillOnce([](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0302(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 168 std::shared_ptr<ScheduleNodeCallback> callback) {
169 // Error: scheduleNodeList size = 2
170 scheduleList.push_back(Common::MakeShared<MockScheduleNode>());
171 scheduleList.push_back(Common::MakeShared<MockScheduleNode>());
172 return true;
173 });
174 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
175 ASSERT_NE(contextCallback, nullptr);
176 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
177 ASSERT_NE(context, nullptr);
178 ASSERT_EQ(context->Start(), false);
179 }
180
181 HWTEST_F(EnrollContextTest, EnrollContextTest_Start_004, TestSize.Level0)
182 {
183 static const uint64_t testContestId = 2;
184
185 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
186 ASSERT_NE(mockEnroll, nullptr);
187 EXPECT_CALL(*mockEnroll, Start(_, _))
188 .Times(Exactly(1))
189 .WillOnce([](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0402(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 190 std::shared_ptr<ScheduleNodeCallback> callback) {
191 // Error: schedule node start fail
192 auto scheduleNode = Common::MakeShared<MockScheduleNode>();
193 EXPECT_NE(scheduleNode, nullptr);
194
195 EXPECT_CALL(*scheduleNode, StartSchedule()).Times(Exactly(1)).WillOnce(Return(false));
196 scheduleList.push_back(scheduleNode);
197 return true;
198 });
199 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
200 ASSERT_NE(contextCallback, nullptr);
201 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
202 ASSERT_NE(context, nullptr);
203 ASSERT_EQ(context->Start(), false);
204 }
205
206 HWTEST_F(EnrollContextTest, EnrollContextTest_Start_005, TestSize.Level0)
207 {
208 static const uint64_t testContestId = 2;
209 static const uint64_t testScheduleId = 3;
210
211 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
212 ASSERT_NE(mockEnroll, nullptr);
213 EXPECT_CALL(*mockEnroll, Start(_, _))
214 .Times(Exactly(1))
215 .WillOnce([](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0502(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 216 std::shared_ptr<ScheduleNodeCallback> callback) {
217 // Success
218 EXPECT_EQ(scheduleList.size(), 0U);
219 auto scheduleNode = Common::MakeShared<MockScheduleNode>();
220 EXPECT_NE(scheduleNode, nullptr);
221 EXPECT_CALL(*scheduleNode, StartSchedule()).Times(Exactly(1)).WillOnce(Return(true));
222 EXPECT_CALL(*scheduleNode, GetScheduleId()).Times(Exactly(2)).WillRepeatedly(Return(testScheduleId));
223 scheduleList.push_back(scheduleNode);
224 return true;
225 });
226 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
227 ASSERT_NE(contextCallback, nullptr);
228 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
229 ASSERT_NE(context, nullptr);
230 ASSERT_EQ(context->Start(), true);
231 ASSERT_EQ(context->Start(), false);
232 auto node = context->GetScheduleNode(testScheduleId);
233 ASSERT_NE(node, nullptr);
234 node = context->GetScheduleNode(testScheduleId + 1);
235 ASSERT_EQ(node, nullptr);
236 }
237
238 HWTEST_F(EnrollContextTest, EnrollContextTest_Stop_001, TestSize.Level0)
239 {
240 static const uint64_t testContestId = 2;
241
242 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
243 ASSERT_NE(mockEnroll, nullptr);
244 EXPECT_CALL(*mockEnroll, GetLatestError()).Times(1);
__anon862f046d0602() 245 EXPECT_CALL(*mockEnroll, Cancel()).Times(Exactly(1)).WillOnce([]() {
246 // Error: enrollment cancel fail
247 return false;
248 });
249 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
250 ASSERT_NE(contextCallback, nullptr);
251 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
252 ASSERT_NE(context, nullptr);
253 ASSERT_EQ(context->Stop(), false);
254 }
255
256 HWTEST_F(EnrollContextTest, EnrollContextTest_Stop_002, TestSize.Level0)
257 {
258 static const uint64_t testContestId = 2;
259 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
260 ASSERT_NE(mockEnroll, nullptr);
__anon862f046d0702() 261 EXPECT_CALL(*mockEnroll, Cancel()).Times(Exactly(1)).WillOnce([]() { return true; });
262 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
263 ASSERT_NE(contextCallback, nullptr);
264 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
265 ASSERT_NE(context, nullptr);
266 ASSERT_EQ(context->Stop(), true);
267 }
268
269 HWTEST_F(EnrollContextTest, EnrollContextTest_Stop_003, TestSize.Level0)
270 {
271 static const uint64_t testContestId = 2;
272
273 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
274 ASSERT_NE(mockEnroll, nullptr);
275 EXPECT_CALL(*mockEnroll, Start(_, _)).Times(1);
276 ON_CALL(*mockEnroll, Start)
277 .WillByDefault(
278 [](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0802(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 279 std::shared_ptr<ScheduleNodeCallback> callback) {
280 scheduleList.push_back(nullptr);
281 return true;
282 }
283 );
__anon862f046d0902() 284 EXPECT_CALL(*mockEnroll, Cancel()).Times(Exactly(1)).WillOnce([]() {
285 return true;
286 });
287 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
288 ASSERT_NE(contextCallback, nullptr);
289 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
290 ASSERT_NE(context, nullptr);
291 ASSERT_EQ(context->Start(), false);
292 ASSERT_EQ(context->Stop(), true);
293 }
294
295 HWTEST_F(EnrollContextTest, EnrollContextTest_Stop_004, TestSize.Level0)
296 {
297 static const uint64_t testContestId = 2;
298
299 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
300 ASSERT_NE(mockEnroll, nullptr);
301 EXPECT_CALL(*mockEnroll, Start(_, _)).Times(1);
302 ON_CALL(*mockEnroll, Start)
303 .WillByDefault(
304 [](std::vector<std::shared_ptr<ScheduleNode>> &scheduleList,
__anon862f046d0a02(std::vector<std::shared_ptr<ScheduleNode>> &scheduleList, std::shared_ptr<ScheduleNodeCallback> callback) 305 std::shared_ptr<ScheduleNodeCallback> callback) {
306 auto scheduleNode = Common::MakeShared<MockScheduleNode>();
307 EXPECT_NE(scheduleNode, nullptr);
308 EXPECT_CALL(*scheduleNode, StartSchedule()).Times(1);
309 EXPECT_CALL(*scheduleNode, StopSchedule()).Times(1);
310 scheduleList.push_back(scheduleNode);
311 return true;
312 }
313 );
314 EXPECT_CALL(*mockEnroll, GetLatestError()).Times(1);
__anon862f046d0b02() 315 EXPECT_CALL(*mockEnroll, Cancel()).Times(Exactly(1)).WillOnce([]() {
316 return false;
317 });
318 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
319 ASSERT_NE(contextCallback, nullptr);
320 std::shared_ptr<Context> context = Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
321 ASSERT_NE(context, nullptr);
322 ASSERT_EQ(context->Start(), false);
323 ASSERT_EQ(context->Stop(), false);
324 }
325
326 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStarted, TestSize.Level0)
327 {
328 static const uint64_t testContestId = 2;
329
330 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
331 ASSERT_NE(mockEnroll, nullptr);
332 std::shared_ptr<ContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
333 ASSERT_NE(contextCallback, nullptr);
334
335 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
336 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
337 ASSERT_NE(nodeCallback, nullptr);
338 nodeCallback->OnScheduleStarted();
339 }
340
341 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleProcessed, TestSize.Level0)
342 {
343 EXPECT_EQ(0, 0);
344 }
345
346 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_001, TestSize.Level0)
347 {
348 static const uint64_t testContestId = 2;
349 static const int32_t testResultCode = 7;
350
351 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
352 ASSERT_NE(mockEnroll, nullptr);
353 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
354 ASSERT_NE(contextCallback, nullptr);
355 EXPECT_CALL(*contextCallback, OnResult(_, _))
356 .Times(Exactly(1))
__anon862f046d0c02(int32_t resultCode, const Attributes &finalResult) 357 .WillOnce([](int32_t resultCode, const Attributes &finalResult) {
358 EXPECT_EQ(resultCode, testResultCode);
359 });
360
361 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
362 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
363 ASSERT_NE(nodeCallback, nullptr);
364 // Error: result is null when testResultCode is not success
365 std::shared_ptr<Attributes> result = nullptr;
366 nodeCallback->OnScheduleStoped(testResultCode, result);
367 }
368
369 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_002, TestSize.Level0)
370 {
371 static const uint64_t testContestId = 2;
372 static const int32_t testResultCode = ResultCode::SUCCESS;
373
374 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
375 ASSERT_NE(mockEnroll, nullptr);
376 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
377 ASSERT_NE(contextCallback, nullptr);
378 EXPECT_CALL(*contextCallback, OnResult(_, _))
379 .Times(Exactly(1))
__anon862f046d0d02(int32_t resultCode, const Attributes &finalResult) 380 .WillOnce([](int32_t resultCode, const Attributes &finalResult) {
381 EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
382 });
383
384 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
385 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
386 ASSERT_NE(nodeCallback, nullptr);
387 // Error: result is null when testResultCode is success
388 std::shared_ptr<Attributes> result = nullptr;
389 nodeCallback->OnScheduleStoped(testResultCode, result);
390 }
391
392 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_003, TestSize.Level0)
393 {
394 static const uint64_t testContestId = 2;
395 static const int32_t testResultCode = ResultCode::SUCCESS;
396
397 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
398 ASSERT_NE(mockEnroll, nullptr);
399 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
400 ASSERT_NE(contextCallback, nullptr);
401 EXPECT_CALL(*contextCallback, OnResult(_, _))
402 .Times(Exactly(1))
__anon862f046d0e02(int32_t resultCode, const Attributes &finalResult) 403 .WillOnce([](int32_t resultCode, const Attributes &finalResult) {
404 EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
405 });
406
407 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
408 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
409 ASSERT_NE(nodeCallback, nullptr);
410 // Error: ATTR_RESULT_CODE is not set
411 std::shared_ptr<Attributes> result = Common::MakeShared<Attributes>();
412 ASSERT_NE(result, nullptr);
413 nodeCallback->OnScheduleStoped(testResultCode, result);
414 }
415
416 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_004, TestSize.Level0)
417 {
418 static const uint64_t testContestId = 2;
419 static const int32_t testResultCode = ResultCode::SUCCESS;
420 static const std::vector<uint8_t> testScheduleResult = {3, 4, 5, 6};
421
422 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
423 ASSERT_NE(mockEnroll, nullptr);
424 EXPECT_CALL(*mockEnroll, GetLatestError()).Times(1);
425 EXPECT_CALL(*mockEnroll, Update(_, _, _, _))
426 .Times(Exactly(1))
427 .WillOnce([](const std::vector<uint8_t> &scheduleResult, uint64_t &credentialId,
__anon862f046d0f02(const std::vector<uint8_t> &scheduleResult, uint64_t &credentialId, std::shared_ptr<CredentialInfo> &info, std::vector<uint8_t> &rootSecret) 428 std::shared_ptr<CredentialInfo> &info, std::vector<uint8_t> &rootSecret) {
429 EXPECT_EQ(scheduleResult, testScheduleResult);
430 return false;
431 });
432 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
433 ASSERT_NE(contextCallback, nullptr);
434 EXPECT_CALL(*contextCallback, OnResult(_, _))
435 .Times(Exactly(1))
__anon862f046d1002(int32_t resultCode, const Attributes &finalResult) 436 .WillOnce([](int32_t resultCode, const Attributes &finalResult) {
437 EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
438 });
439
440 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
441 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
442 ASSERT_NE(nodeCallback, nullptr);
443 // Error: enroll_->Update return false
444 std::shared_ptr<Attributes> result = Common::MakeShared<Attributes>();
445 ASSERT_NE(result, nullptr);
446 bool ret1 = result->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, testScheduleResult);
447 ASSERT_EQ(ret1, true);
448
449 bool ret2 = result->SetUint8ArrayValue(Attributes::ATTR_RESULT, testScheduleResult);
450 ASSERT_EQ(ret2, true);
451 nodeCallback->OnScheduleStoped(testResultCode, result);
452 }
453
454 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_005, TestSize.Level0)
455 {
456 static const uint64_t testContestId = 2;
457 static const std::vector<uint8_t> testScheduleResult = {3, 4, 5, 6};
458 static const uint64_t testCredentialId = 7;
459
460 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
461 ASSERT_NE(mockEnroll, nullptr);
462 EXPECT_CALL(*mockEnroll, Update(_, _, _, _))
463 .Times(Exactly(1))
464 .WillOnce([](const std::vector<uint8_t> &scheduleResult, uint64_t &credentialId,
__anon862f046d1102(const std::vector<uint8_t> &scheduleResult, uint64_t &credentialId, std::shared_ptr<CredentialInfo> &info, std::vector<uint8_t> &rootSecret) 465 std::shared_ptr<CredentialInfo> &info, std::vector<uint8_t> &rootSecret) {
466 EXPECT_EQ(scheduleResult, testScheduleResult);
467 credentialId = testCredentialId;
468 info = nullptr;
469 rootSecret = {};
470 return true;
471 });
472 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
473 ASSERT_NE(contextCallback, nullptr);
474 EXPECT_CALL(*contextCallback, OnResult(_, _))
475 .Times(Exactly(1))
__anon862f046d1202(int32_t resultCode, const Attributes &finalResult) 476 .WillOnce([](int32_t resultCode, const Attributes &finalResult) {
477 EXPECT_EQ(resultCode, ResultCode::SUCCESS);
478 uint64_t credentialId;
479 bool ret = finalResult.GetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId);
480 EXPECT_EQ(ret, true);
481 EXPECT_EQ(testCredentialId, credentialId);
482 });
483
484 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
485 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
486 ASSERT_NE(nodeCallback, nullptr);
487 // Success
488 std::shared_ptr<Attributes> result = Common::MakeShared<Attributes>();
489 ASSERT_NE(result, nullptr);
490 bool ret1 = result->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, testScheduleResult);
491 ASSERT_EQ(ret1, true);
492
493 bool ret2 = result->SetUint8ArrayValue(Attributes::ATTR_RESULT, testScheduleResult);
494 ASSERT_EQ(ret2, true);
495 nodeCallback->OnScheduleStoped(ResultCode::SUCCESS, result);
496 }
497
498 HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_006, TestSize.Level0)
499 {
500 static const uint64_t testContestId = 2;
501 static const std::vector<uint8_t> testScheduleResult = {3, 4, 5, 6};
502 static const uint64_t testCredentialId = 7;
503
504 std::shared_ptr<MockEnrollment> mockEnroll = Common::MakeShared<MockEnrollment>();
505 ASSERT_NE(mockEnroll, nullptr);
506 EXPECT_CALL(*mockEnroll, Update(_, _, _, _))
507 .Times(Exactly(1))
508 .WillOnce([](const std::vector<uint8_t> &scheduleResult, uint64_t &credentialId,
__anon862f046d1302(const std::vector<uint8_t> &scheduleResult, uint64_t &credentialId, std::shared_ptr<CredentialInfo> &info, std::vector<uint8_t> &rootSecret) 509 std::shared_ptr<CredentialInfo> &info, std::vector<uint8_t> &rootSecret) {
510 EXPECT_EQ(scheduleResult, testScheduleResult);
511 credentialId = testCredentialId;
512 auto credInfo = Common::MakeShared<MockCredentialInfo>();
513 EXPECT_NE(credInfo, nullptr);
514 EXPECT_CALL(*credInfo, GetExecutorIndex()).WillOnce(Return(10));
515 info = credInfo;
516 rootSecret = {1, 2, 3, 4};
517 return true;
518 });
519 std::shared_ptr<MockContextCallback> contextCallback = Common::MakeShared<MockContextCallback>();
520 ASSERT_NE(contextCallback, nullptr);
521 EXPECT_CALL(*contextCallback, OnResult(_, _)).Times(1);
522
523 std::shared_ptr<ScheduleNodeCallback> nodeCallback =
524 Common::MakeShared<EnrollContext>(testContestId, mockEnroll, contextCallback);
525 ASSERT_NE(nodeCallback, nullptr);
526 // Success
527 std::shared_ptr<Attributes> result = Common::MakeShared<Attributes>();
528 ASSERT_NE(result, nullptr);
529 bool ret1 = result->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, testScheduleResult);
530 ASSERT_EQ(ret1, true);
531
532 bool ret2 = result->SetUint8ArrayValue(Attributes::ATTR_RESULT, testScheduleResult);
533 ASSERT_EQ(ret2, true);
534 nodeCallback->OnScheduleStoped(ResultCode::SUCCESS, result);
535 }
536 } // namespace UserAuth
537 } // namespace UserIam
538 } // namespace OHOS
539