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 "auth_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 AuthCommandUnitTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void AuthCommandUnitTest::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void AuthCommandUnitTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void AuthCommandUnitTest::SetUp()
56 {
57 }
58
TearDown()59 void AuthCommandUnitTest::TearDown()
60 {
61 }
62
63 HWTEST_F(AuthCommandUnitTest, AuthCommand_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))
__anon53f2baf20102(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<AuthCommand>(executor, testScheduleId, attr, messenger);
89 ASSERT_NE(command, nullptr);
90 command->OnResult(testResultCode, testExtraInfo);
91 }
92
93 HWTEST_F(AuthCommandUnitTest, AuthCommand_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))
__anon53f2baf20202(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 USERAUTH_ERROR;
105 });
106 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
107 ASSERT_NE(executor, nullptr);
108 Attributes attr;
109 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
110 ASSERT_NE(command, nullptr);
111 command->OnResult(testResultCode, testExtraInfo);
112 }
113
114 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnResultTest_003, TestSize.Level0)
115 {
116 static const uint64_t testScheduleId = 123;
117 static const ResultCode testResultCode = static_cast<ResultCode>(456);
118 static const std::vector<uint8_t> testExtraInfo = {};
119
120 auto messenger = MakeShared<MockIExecutorMessenger>();
121 ASSERT_NE(messenger, nullptr);
122 EXPECT_CALL(*messenger, Finish(_, _, _, _))
123 .Times(Exactly(1))
__anon53f2baf20302(uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) 124 .WillOnce([](uint64_t scheduleId, ExecutorRole srcRole, int32_t resultCode, const Attributes &finalResult) {
125 EXPECT_EQ(scheduleId, testScheduleId);
126 EXPECT_EQ(srcRole, ALL_IN_ONE);
127 EXPECT_EQ(resultCode, testResultCode);
128 uint32_t attrResultCode;
129 EXPECT_EQ(finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode), true);
130 EXPECT_EQ(attrResultCode, static_cast<uint32_t>(testResultCode));
131 std::vector<uint8_t> extraInfo;
132 EXPECT_EQ(finalResult.GetUint8ArrayValue(Attributes::ATTR_RESULT, extraInfo), true);
133 EXPECT_EQ(extraInfo, testExtraInfo);
134 return USERAUTH_SUCCESS;
135 });
136 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
137 ASSERT_NE(executor, nullptr);
138 Attributes attr;
139 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
140 ASSERT_NE(command, nullptr);
141 command->OnResult(testResultCode);
142 }
143
144 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnResultTest_004, TestSize.Level0)
145 {
146 static const uint64_t testScheduleId = 123;
147 static const ResultCode testResultCode = static_cast<ResultCode>(456);
148 static const std::vector<uint8_t> testExtraInfo = {};
149
150 auto messenger = MakeShared<MockIExecutorMessenger>();
151 ASSERT_NE(messenger, nullptr);
152 EXPECT_CALL(*messenger, Finish(_, _, _, _)).Times(Exactly(1));
153 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
154 ASSERT_NE(executor, nullptr);
155 Attributes attr;
156 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
157 ASSERT_NE(command, nullptr);
158 command->OnResult(testResultCode);
159 command->OnResult(testResultCode);
160 command->OnResult(testResultCode);
161 }
162
163 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnAcquireInfoTest_001, TestSize.Level0)
164 {
165 static const uint64_t testScheduleId = 123;
166 static const uint64_t testAcquire = 456;
167 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
168
169 auto messenger = MakeShared<MockIExecutorMessenger>();
170 ASSERT_NE(messenger, nullptr);
171 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
172 .Times(Exactly(1))
173 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anon53f2baf20402(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 174 const std::shared_ptr<AuthMessage> &msg) {
175 EXPECT_EQ(scheduleId, testScheduleId);
176 EXPECT_EQ(transNum, static_cast<uint64_t>(1));
177 EXPECT_EQ(srcRole, ALL_IN_ONE);
178 EXPECT_EQ(dstRole, SCHEDULER);
179 EXPECT_NE(msg, nullptr);
180 return USERAUTH_SUCCESS;
181 });
182 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
183 ASSERT_NE(executor, nullptr);
184 Attributes attr;
185 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
186 ASSERT_NE(command, nullptr);
187 command->OnAcquireInfo(testAcquire, testExtraInfo);
188 }
189
190 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnAcquireInfoTest_002, TestSize.Level0)
191 {
192 static const uint64_t testScheduleId = 123;
193 static const uint64_t testAcquire = 456;
194 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
195
196 auto messenger = MakeShared<MockIExecutorMessenger>();
197 ASSERT_NE(messenger, nullptr);
198 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
199 .Times(Exactly(1))
200 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anon53f2baf20502(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 201 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_ERROR; });
202 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
203 ASSERT_NE(executor, nullptr);
204 Attributes attr;
205 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
206 ASSERT_NE(command, nullptr);
207 command->OnAcquireInfo(testAcquire, testExtraInfo);
208 }
209
210 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnAcquireInfoTest_003, TestSize.Level0)
211 {
212 static const uint64_t testScheduleId = 123;
213 static const uint64_t testAcquire = 456;
214 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
215
216 auto messenger = MakeShared<MockIExecutorMessenger>();
217 ASSERT_NE(messenger, nullptr);
218 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
219 .Times(Exactly(3))
220 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anon53f2baf20602(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 221 const std::shared_ptr<AuthMessage> &msg) {
222 EXPECT_EQ(transNum, static_cast<uint64_t>(1));
223 return USERAUTH_SUCCESS;
224 })
225 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anon53f2baf20702(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 226 const std::shared_ptr<AuthMessage> &msg) {
227 EXPECT_EQ(transNum, static_cast<uint64_t>(2));
228 return USERAUTH_ERROR;
229 })
230 .WillOnce([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anon53f2baf20802(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 231 const std::shared_ptr<AuthMessage> &msg) {
232 EXPECT_EQ(transNum, static_cast<uint64_t>(3));
233 return USERAUTH_SUCCESS;
234 });
235 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
236 ASSERT_NE(executor, nullptr);
237 Attributes attr;
238 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
239 ASSERT_NE(command, nullptr);
240 command->OnAcquireInfo(testAcquire, testExtraInfo);
241 command->OnAcquireInfo(testAcquire, testExtraInfo);
242 command->OnAcquireInfo(testAcquire, testExtraInfo);
243 }
244
245 HWTEST_F(AuthCommandUnitTest, AuthCommand_MixTest_003, TestSize.Level0)
246 {
247 static const uint64_t testScheduleId = 123;
248 static const uint64_t testAcquire = 456;
249 static const ResultCode testResultCode = static_cast<ResultCode>(456);
250 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
251
252 auto messenger = MakeShared<MockIExecutorMessenger>();
253 ASSERT_NE(messenger, nullptr);
254 EXPECT_CALL(*messenger, Finish(_, _, _, _)).Times(Exactly(1));
255 EXPECT_CALL(*messenger, SendData(_, _, _, _, _))
256 .Times(Exactly(3))
257 .WillRepeatedly([](uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole,
__anon53f2baf20902(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 258 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_SUCCESS; });
259 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
260 ASSERT_NE(executor, nullptr);
261 Attributes attr;
262 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
263 ASSERT_NE(command, nullptr);
264 command->OnAcquireInfo(testAcquire, testExtraInfo);
265 command->OnAcquireInfo(testAcquire, testExtraInfo);
266 command->OnAcquireInfo(testAcquire, testExtraInfo);
267 command->OnResult(testResultCode);
268 command->OnAcquireInfo(testAcquire, testExtraInfo);
269 command->OnResult(testResultCode);
270 command->OnAcquireInfo(testAcquire, testExtraInfo);
271 command->OnAcquireInfo(testAcquire, testExtraInfo);
272 }
273 } // namespace UserAuth
274 } // namespace UserIam
275 } // namespace OHOS
276