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_TAG "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))
__anon365e08aa0102(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 73 .WillOnce([](uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) {
74 EXPECT_EQ(scheduleId, testScheduleId);
75 EXPECT_EQ(resultCode, testResultCode);
76 uint32_t attrResultCode;
77 EXPECT_EQ(finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode), true);
78 EXPECT_EQ(attrResultCode, static_cast<uint32_t>(testResultCode));
79 std::vector<uint8_t> extraInfo;
80 EXPECT_EQ(finalResult.GetUint8ArrayValue(Attributes::ATTR_RESULT, extraInfo), true);
81 EXPECT_EQ(extraInfo, testExtraInfo);
82 return USERAUTH_SUCCESS;
83 });
84 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
85 ASSERT_NE(executor, nullptr);
86 Attributes attr;
87 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
88 ASSERT_NE(command, nullptr);
89 command->OnResult(testResultCode, testExtraInfo);
90 }
91
92 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnResultTest_002, TestSize.Level0)
93 {
94 static const uint64_t testScheduleId = 123;
95 static const ResultCode testResultCode = static_cast<ResultCode>(456);
96 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
97
98 auto messenger = MakeShared<MockIExecutorMessenger>();
99 ASSERT_NE(messenger, nullptr);
100 EXPECT_CALL(*messenger, Finish(_, _, _))
101 .Times(Exactly(1))
__anon365e08aa0202(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 102 .WillOnce([](uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) {
103 return USERAUTH_ERROR;
104 });
105 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
106 ASSERT_NE(executor, nullptr);
107 Attributes attr;
108 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
109 ASSERT_NE(command, nullptr);
110 command->OnResult(testResultCode, testExtraInfo);
111 }
112
113 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnResultTest_003, TestSize.Level0)
114 {
115 static const uint64_t testScheduleId = 123;
116 static const ResultCode testResultCode = static_cast<ResultCode>(456);
117 static const std::vector<uint8_t> testExtraInfo = {};
118
119 auto messenger = MakeShared<MockIExecutorMessenger>();
120 ASSERT_NE(messenger, nullptr);
121 EXPECT_CALL(*messenger, Finish(_, _, _))
122 .Times(Exactly(1))
__anon365e08aa0302(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 123 .WillOnce([](uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) {
124 EXPECT_EQ(scheduleId, testScheduleId);
125 EXPECT_EQ(resultCode, testResultCode);
126 uint32_t attrResultCode;
127 EXPECT_EQ(finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode), true);
128 EXPECT_EQ(attrResultCode, static_cast<uint32_t>(testResultCode));
129 std::vector<uint8_t> extraInfo;
130 EXPECT_EQ(finalResult.GetUint8ArrayValue(Attributes::ATTR_RESULT, extraInfo), true);
131 EXPECT_EQ(extraInfo, testExtraInfo);
132 return USERAUTH_SUCCESS;
133 });
134 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
135 ASSERT_NE(executor, nullptr);
136 Attributes attr;
137 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
138 ASSERT_NE(command, nullptr);
139 command->OnResult(testResultCode);
140 }
141
142 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnResultTest_004, TestSize.Level0)
143 {
144 static const uint64_t testScheduleId = 123;
145 static const ResultCode testResultCode = static_cast<ResultCode>(456);
146 static const std::vector<uint8_t> testExtraInfo = {};
147
148 auto messenger = MakeShared<MockIExecutorMessenger>();
149 ASSERT_NE(messenger, nullptr);
150 EXPECT_CALL(*messenger, Finish(_, _, _)).Times(Exactly(1));
151 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
152 ASSERT_NE(executor, nullptr);
153 Attributes attr;
154 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
155 ASSERT_NE(command, nullptr);
156 command->OnResult(testResultCode);
157 command->OnResult(testResultCode);
158 command->OnResult(testResultCode);
159 }
160
161 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnAcquireInfoTest_001, TestSize.Level0)
162 {
163 static const uint64_t testScheduleId = 123;
164 static const uint64_t testAcquire = 456;
165 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
166
167 auto messenger = MakeShared<MockIExecutorMessenger>();
168 ASSERT_NE(messenger, nullptr);
169 EXPECT_CALL(*messenger, SendData(_, _, _))
170 .Times(Exactly(1))
171 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole,
__anon365e08aa0402(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 172 const std::shared_ptr<AuthMessage> &msg) {
173 EXPECT_EQ(scheduleId, testScheduleId);
174 EXPECT_EQ(dstRole, SCHEDULER);
175 EXPECT_NE(msg, nullptr);
176 return USERAUTH_SUCCESS;
177 });
178 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
179 ASSERT_NE(executor, nullptr);
180 Attributes attr;
181 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
182 ASSERT_NE(command, nullptr);
183 command->OnAcquireInfo(testAcquire, testExtraInfo);
184 }
185
186 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnAcquireInfoTest_002, TestSize.Level0)
187 {
188 static const uint64_t testScheduleId = 123;
189 static const uint64_t testAcquire = 456;
190 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
191
192 auto messenger = MakeShared<MockIExecutorMessenger>();
193 ASSERT_NE(messenger, nullptr);
194 EXPECT_CALL(*messenger, SendData(_, _, _))
195 .Times(Exactly(1))
196 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole,
__anon365e08aa0502(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 197 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_ERROR; });
198 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
199 ASSERT_NE(executor, nullptr);
200 Attributes attr;
201 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
202 ASSERT_NE(command, nullptr);
203 command->OnAcquireInfo(testAcquire, testExtraInfo);
204 }
205
206 HWTEST_F(AuthCommandUnitTest, AuthCommand_OnAcquireInfoTest_003, TestSize.Level0)
207 {
208 static const uint64_t testScheduleId = 123;
209 static const uint64_t testAcquire = 456;
210 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
211
212 auto messenger = MakeShared<MockIExecutorMessenger>();
213 ASSERT_NE(messenger, nullptr);
214 EXPECT_CALL(*messenger, SendData(_, _, _))
215 .Times(Exactly(3))
__anon365e08aa0602(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 216 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) {
217 return USERAUTH_SUCCESS;
218 })
__anon365e08aa0702(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 219 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) {
220 return USERAUTH_ERROR;
221 })
__anon365e08aa0802(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 222 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) {
223 return USERAUTH_SUCCESS;
224 });
225 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
226 ASSERT_NE(executor, nullptr);
227 Attributes attr;
228 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
229 ASSERT_NE(command, nullptr);
230 command->OnAcquireInfo(testAcquire, testExtraInfo);
231 command->OnAcquireInfo(testAcquire, testExtraInfo);
232 command->OnAcquireInfo(testAcquire, testExtraInfo);
233 }
234
235 HWTEST_F(AuthCommandUnitTest, AuthCommand_MixTest_003, TestSize.Level0)
236 {
237 static const uint64_t testScheduleId = 123;
238 static const uint64_t testAcquire = 456;
239 static const ResultCode testResultCode = static_cast<ResultCode>(456);
240 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
241
242 auto messenger = MakeShared<MockIExecutorMessenger>();
243 ASSERT_NE(messenger, nullptr);
244 EXPECT_CALL(*messenger, Finish(_, _, _)).Times(Exactly(1));
245 EXPECT_CALL(*messenger, SendData(_, _, _))
246 .Times(Exactly(3))
247 .WillRepeatedly([](uint64_t scheduleId, ExecutorRole dstRole,
__anon365e08aa0902(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 248 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_SUCCESS; });
249 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
250 ASSERT_NE(executor, nullptr);
251 Attributes attr;
252 auto command = Common::MakeShared<AuthCommand>(executor, testScheduleId, attr, messenger);
253 ASSERT_NE(command, nullptr);
254 command->OnAcquireInfo(testAcquire, testExtraInfo);
255 command->OnAcquireInfo(testAcquire, testExtraInfo);
256 command->OnAcquireInfo(testAcquire, testExtraInfo);
257 command->OnResult(testResultCode);
258 command->OnAcquireInfo(testAcquire, testExtraInfo);
259 command->OnResult(testResultCode);
260 command->OnAcquireInfo(testAcquire, testExtraInfo);
261 command->OnAcquireInfo(testAcquire, testExtraInfo);
262 }
263 } // namespace UserAuth
264 } // namespace UserIam
265 } // namespace OHOS
266