1 /*
2 * Copyright (c) 2021-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 "gtest/gtest.h"
17
18 #include "enroll_command.h"
19 #include "iam_check.h"
20 #include "iam_logger.h"
21 #include "iam_mem.h"
22 #include "iam_ptr.h"
23
24 #include "executor.h"
25 #include "mock_iexecutor_messenger.h"
26
27 #define LOG_LABEL UserIam::Common::LABEL_USER_AUTH_EXECUTOR
28
29 using namespace std;
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace OHOS::UserIam;
33 using namespace OHOS::UserIam::Common;
34 using namespace OHOS::UserIam::UserAuth;
35
36 namespace OHOS {
37 namespace UserIam {
38 namespace UserAuth {
39 class EnrollCommandUnitTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void EnrollCommandUnitTest::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void EnrollCommandUnitTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void EnrollCommandUnitTest::SetUp()
56 {
57 }
58
TearDown()59 void EnrollCommandUnitTest::TearDown()
60 {
61 }
62
63 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnResultTest_001, TestSize.Level0)
64 {
65 static const uint64_t testScheduleId = 123;
66 static const ResultCode testResultCode = static_cast<ResultCode>(456);
67 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
68
69 auto messenger = MakeShared<MockIExecutorMessenger>();
70 ASSERT_NE(messenger, nullptr);
71 EXPECT_CALL(*messenger, Finish(_, _, _, _))
72 .Times(Exactly(1))
__anone61cc20c0102(uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) 73 .WillOnce([](uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) {
74 EXPECT_EQ(scheduleId, testScheduleId);
75 EXPECT_EQ(srcRole, ALL_IN_ONE);
76 EXPECT_EQ(resultCode, testResultCode);
77 uint32_t attrResultCode;
78 EXPECT_EQ(finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode), true);
79 EXPECT_EQ(attrResultCode, static_cast<uint32_t>(testResultCode));
80 std::vector<uint8_t> extraInfo;
81 EXPECT_EQ(finalResult.GetUint8ArrayValue(Attributes::ATTR_RESULT, extraInfo), true);
82 EXPECT_EQ(extraInfo, testExtraInfo);
83 return USERAUTH_SUCCESS;
84 });
85 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
86 ASSERT_NE(executor, nullptr);
87 Attributes attr;
88 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
89 ASSERT_NE(command, nullptr);
90 command->OnResult(testResultCode, testExtraInfo);
91 }
92
93 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnResultTest_002, TestSize.Level0)
94 {
95 static const uint64_t testScheduleId = 123;
96 static const ResultCode testResultCode = static_cast<ResultCode>(456);
97 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
98
99 auto messenger = MakeShared<MockIExecutorMessenger>();
100 ASSERT_NE(messenger, nullptr);
101 EXPECT_CALL(*messenger, Finish(_, _, _, _))
102 .Times(Exactly(1))
__anone61cc20c0202(uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) 103 .WillOnce([](uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) {
104 // return error
105 return USERAUTH_ERROR;
106 });
107 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
108 ASSERT_NE(executor, nullptr);
109 Attributes attr;
110 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
111 ASSERT_NE(command, nullptr);
112 command->OnResult(testResultCode, testExtraInfo);
113 }
114
115 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnResultTest_003, TestSize.Level0)
116 {
117 static const uint64_t testScheduleId = 123;
118 static const ResultCode testResultCode = static_cast<ResultCode>(456);
119 static const std::vector<uint8_t> testExtraInfo = {};
120
121 auto messenger = MakeShared<MockIExecutorMessenger>();
122 ASSERT_NE(messenger, nullptr);
123 EXPECT_CALL(*messenger, Finish(_, _, _, _))
124 .Times(Exactly(1))
__anone61cc20c0302(uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) 125 .WillOnce([](uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) {
126 EXPECT_EQ(scheduleId, testScheduleId);
127 EXPECT_EQ(srcRole, ALL_IN_ONE);
128 EXPECT_EQ(resultCode, testResultCode);
129 uint32_t attrResultCode;
130 EXPECT_EQ(finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode), true);
131 EXPECT_EQ(attrResultCode, static_cast<uint32_t>(testResultCode));
132 std::vector<uint8_t> extraInfo;
133 EXPECT_EQ(finalResult.GetUint8ArrayValue(Attributes::ATTR_RESULT, extraInfo), true);
134 EXPECT_EQ(extraInfo, testExtraInfo);
135 return USERAUTH_SUCCESS;
136 });
137 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
138 ASSERT_NE(executor, nullptr);
139 Attributes attr;
140 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
141 ASSERT_NE(command, nullptr);
142 command->OnResult(testResultCode);
143 }
144
145 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnResultTest_004, TestSize.Level0)
146 {
147 static const uint64_t testScheduleId = 123;
148 static const ResultCode testResultCode = static_cast<ResultCode>(456);
149 static const std::vector<uint8_t> testExtraInfo = {};
150
151 auto messenger = MakeShared<MockIExecutorMessenger>();
152 ASSERT_NE(messenger, nullptr);
153 EXPECT_CALL(*messenger, Finish(_, _, _, _)).Times(Exactly(1));
154 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
155 ASSERT_NE(executor, nullptr);
156 Attributes attr;
157 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
158 ASSERT_NE(command, nullptr);
159 command->OnResult(testResultCode);
160 command->OnResult(testResultCode);
161 command->OnResult(testResultCode);
162 }
163
164 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnAcquireInfoTest_001, TestSize.Level0)
165 {
166 static const uint64_t testScheduleId = 123;
167 static const uint64_t testAcquire = 456;
168 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
169
170 auto messenger = MakeShared<MockIExecutorMessenger>();
171 ASSERT_NE(messenger, nullptr);
172 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
173 .Times(Exactly(1))
174 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anone61cc20c0402(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 175 const std::shared_ptr<AuthMessage> &msg) {
176 EXPECT_EQ(scheduleId, testScheduleId);
177 EXPECT_EQ(transNum, static_cast<uint64_t>(1));
178 EXPECT_EQ(srcRole, ALL_IN_ONE);
179 EXPECT_EQ(dstRole, SCHEDULER);
180 EXPECT_NE(msg, nullptr);
181 std::vector<uint8_t> extraInfo;
182 return USERAUTH_SUCCESS;
183 });
184 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
185 ASSERT_NE(executor, nullptr);
186 Attributes attr;
187 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
188 ASSERT_NE(command, nullptr);
189 command->OnAcquireInfo(testAcquire, testExtraInfo);
190 }
191
192 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnAcquireInfoTest_002, TestSize.Level0)
193 {
194 static const uint64_t testScheduleId = 123;
195 static const uint64_t testAcquire = 456;
196 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
197
198 auto messenger = MakeShared<MockIExecutorMessenger>();
199 ASSERT_NE(messenger, nullptr);
200 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
201 .Times(Exactly(1))
202 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anone61cc20c0502(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 203 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_ERROR; });
204 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
205 ASSERT_NE(executor, nullptr);
206 Attributes attr;
207 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
208 ASSERT_NE(command, nullptr);
209 command->OnAcquireInfo(testAcquire, testExtraInfo);
210 }
211
212 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_OnAcquireInfoTest_003, TestSize.Level0)
213 {
214 static const uint64_t testScheduleId = 123;
215 static const uint64_t testAcquire = 456;
216 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
217
218 auto messenger = MakeShared<MockIExecutorMessenger>();
219 ASSERT_NE(messenger, nullptr);
220 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
221 .Times(Exactly(3))
222 .WillOnce([](uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType,
__anone61cc20c0602(uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType, std::shared_ptr<AuthMessage> msg) 223 std::shared_ptr<AuthMessage> msg) {
224 EXPECT_EQ(transNum, static_cast<uint64_t>(1));
225 return USERAUTH_SUCCESS;
226 })
227 .WillOnce([](uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType,
__anone61cc20c0702(uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType, std::shared_ptr<AuthMessage> msg) 228 std::shared_ptr<AuthMessage> msg) {
229 EXPECT_EQ(transNum, static_cast<uint64_t>(2));
230 return USERAUTH_ERROR;
231 })
232 .WillOnce([](uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType,
__anone61cc20c0802(uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType, std::shared_ptr<AuthMessage> msg) 233 std::shared_ptr<AuthMessage> msg) {
234 EXPECT_EQ(transNum, static_cast<uint64_t>(3));
235 return USERAUTH_SUCCESS;
236 });
237 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
238 ASSERT_NE(executor, nullptr);
239 Attributes attr;
240 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
241 ASSERT_NE(command, nullptr);
242 command->OnAcquireInfo(testAcquire, testExtraInfo);
243 command->OnAcquireInfo(testAcquire, testExtraInfo);
244 command->OnAcquireInfo(testAcquire, testExtraInfo);
245 }
246
247 HWTEST_F(EnrollCommandUnitTest, EnrollCommand_MixTest_003, TestSize.Level0)
248 {
249 static const uint64_t testScheduleId = 123;
250 static const uint64_t testAcquire = 456;
251 static const ResultCode testResultCode = static_cast<ResultCode>(456);
252 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
253
254 auto messenger = MakeShared<MockIExecutorMessenger>();
255 ASSERT_NE(messenger, nullptr);
256 EXPECT_CALL(*messenger, Finish(_, _, _, _)).Times(Exactly(1));
257 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
258 .Times(Exactly(3))
259 .WillRepeatedly([](uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType,
__anone61cc20c0902(uint64_t scheduleId, uint64_t transNum, int32_t srcType, int32_t dstType, std::shared_ptr<AuthMessage> msg) 260 std::shared_ptr<AuthMessage> msg) { return USERAUTH_SUCCESS; });
261 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
262 ASSERT_NE(executor, nullptr);
263 Attributes attr;
264 auto command = Common::MakeShared<EnrollCommand>(executor, testScheduleId, attr, messenger);
265 ASSERT_NE(command, nullptr);
266 command->OnAcquireInfo(testAcquire, testExtraInfo);
267 command->OnAcquireInfo(testAcquire, testExtraInfo);
268 command->OnAcquireInfo(testAcquire, testExtraInfo);
269 command->OnResult(testResultCode);
270 command->OnAcquireInfo(testAcquire, testExtraInfo);
271 command->OnResult(testResultCode);
272 command->OnAcquireInfo(testAcquire, testExtraInfo);
273 command->OnAcquireInfo(testAcquire, testExtraInfo);
274 }
275 } // namespace UserAuth
276 } // namespace UserIam
277 } // namespace OHOS
278