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 "iam_check.h"
19 #include "iam_logger.h"
20 #include "iam_mem.h"
21 #include "iam_ptr.h"
22 #include "identify_command.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 IdentifyCommandUnitTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void IdentifyCommandUnitTest::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void IdentifyCommandUnitTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void IdentifyCommandUnitTest::SetUp()
56 {
57 }
58
TearDown()59 void IdentifyCommandUnitTest::TearDown()
60 {
61 }
62
63 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_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))
__anonec55d0fc0102(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<IdentifyCommand>(executor, testScheduleId, attr, messenger);
89 ASSERT_NE(command, nullptr);
90 command->OnResult(testResultCode, testExtraInfo);
91 }
92
93 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_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))
__anonec55d0fc0202(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<IdentifyCommand>(executor, testScheduleId, attr, messenger);
111 ASSERT_NE(command, nullptr);
112 command->OnResult(testResultCode, testExtraInfo);
113 }
114
115 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_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))
__anonec55d0fc0302(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<IdentifyCommand>(executor, testScheduleId, attr, messenger);
141 ASSERT_NE(command, nullptr);
142 command->OnResult(testResultCode);
143 }
144
145 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_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<IdentifyCommand>(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(IdentifyCommandUnitTest, IdentifyCommand_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,
__anonec55d0fc0402(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 return USERAUTH_SUCCESS;
182 });
183 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
184 ASSERT_NE(executor, nullptr);
185 Attributes attr;
186 auto command = Common::MakeShared<IdentifyCommand>(executor, testScheduleId, attr, messenger);
187 ASSERT_NE(command, nullptr);
188 command->OnAcquireInfo(testAcquire, testExtraInfo);
189 }
190
191 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_OnAcquireInfoTest_002, TestSize.Level0)
192 {
193 static const uint64_t testScheduleId = 123;
194 static const uint64_t testAcquire = 456;
195 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
196
197 auto messenger = MakeShared<MockIExecutorMessenger>();
198 ASSERT_NE(messenger, nullptr);
199 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
200 .Times(Exactly(1))
201 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anonec55d0fc0502(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 202 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_ERROR; });
203 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
204 ASSERT_NE(executor, nullptr);
205 Attributes attr;
206 auto command = Common::MakeShared<IdentifyCommand>(executor, testScheduleId, attr, messenger);
207 ASSERT_NE(command, nullptr);
208 command->OnAcquireInfo(testAcquire, testExtraInfo);
209 }
210
211 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_OnAcquireInfoTest_003, TestSize.Level0)
212 {
213 static const uint64_t testScheduleId = 123;
214 static const uint64_t testAcquire = 456;
215 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
216
217 auto messenger = MakeShared<MockIExecutorMessenger>();
218 ASSERT_NE(messenger, nullptr);
219 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
220 .Times(Exactly(3))
221 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anonec55d0fc0602(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 222 const std::shared_ptr<AuthMessage> &msg) {
223 EXPECT_EQ(transNum, static_cast<uint64_t>(1));
224 return USERAUTH_SUCCESS;
225 })
226 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anonec55d0fc0702(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 227 const std::shared_ptr<AuthMessage> &msg) {
228 EXPECT_EQ(transNum, static_cast<uint64_t>(2));
229 return USERAUTH_ERROR;
230 })
231 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anonec55d0fc0802(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 232 const std::shared_ptr<AuthMessage> &msg) {
233 EXPECT_EQ(transNum, static_cast<uint64_t>(3));
234 return USERAUTH_SUCCESS;
235 });
236 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
237 ASSERT_NE(executor, nullptr);
238 Attributes attr;
239 auto command = Common::MakeShared<IdentifyCommand>(executor, testScheduleId, attr, messenger);
240 ASSERT_NE(command, nullptr);
241 command->OnAcquireInfo(testAcquire, testExtraInfo);
242 command->OnAcquireInfo(testAcquire, testExtraInfo);
243 command->OnAcquireInfo(testAcquire, testExtraInfo);
244 }
245
246 HWTEST_F(IdentifyCommandUnitTest, IdentifyCommand_MixTest_003, TestSize.Level0)
247 {
248 static const uint64_t testScheduleId = 123;
249 static const uint64_t testAcquire = 456;
250 static const ResultCode testResultCode = static_cast<ResultCode>(456);
251 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
252
253 auto messenger = MakeShared<MockIExecutorMessenger>();
254 ASSERT_NE(messenger, nullptr);
255 EXPECT_CALL(*messenger, Finish(_, _, _, _)).Times(Exactly(1));
256 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
257 .Times(Exactly(3))
258 .WillRepeatedly([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anonec55d0fc0902(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 259 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_SUCCESS; });
260 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
261 ASSERT_NE(executor, nullptr);
262 Attributes attr;
263 auto command = Common::MakeShared<IdentifyCommand>(executor, testScheduleId, attr, messenger);
264 ASSERT_NE(command, nullptr);
265 command->OnAcquireInfo(testAcquire, testExtraInfo);
266 command->OnAcquireInfo(testAcquire, testExtraInfo);
267 command->OnAcquireInfo(testAcquire, testExtraInfo);
268 command->OnResult(testResultCode);
269 command->OnAcquireInfo(testAcquire, testExtraInfo);
270 command->OnResult(testResultCode);
271 command->OnAcquireInfo(testAcquire, testExtraInfo);
272 command->OnAcquireInfo(testAcquire, testExtraInfo);
273 }
274 } // namespace UserAuth
275 } // namespace UserIam
276 } // namespace OHOS
277