1 /*
2 * Copyright (c) 2025 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 "abandon_command.h"
19 #include "iam_check.h"
20 #include "iam_logger.h"
21 #include "iam_mem.h"
22 #include "iam_ptr.h"
23 #include "async_command_base.h"
24
25 #include "executor.h"
26 #include "mock_iexecutor_messenger.h"
27
28 #define LOG_TAG "USER_AUTH_EXECUTOR"
29
30 using namespace std;
31 using namespace testing;
32 using namespace testing::ext;
33 using namespace OHOS::UserIam;
34 using namespace OHOS::UserIam::Common;
35 using namespace OHOS::UserIam::UserAuth;
36
37 namespace OHOS {
38 namespace UserIam {
39 namespace UserAuth {
40 class AbandonCommandUnitTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase()48 void AbandonCommandUnitTest::SetUpTestCase()
49 {
50 }
51
TearDownTestCase()52 void AbandonCommandUnitTest::TearDownTestCase()
53 {
54 }
55
SetUp()56 void AbandonCommandUnitTest::SetUp()
57 {
58 }
59
TearDown()60 void AbandonCommandUnitTest::TearDown()
61 {
62 }
63
64 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_OnResultTest_001, TestSize.Level0)
65 {
66 static const uint64_t testScheduleId = 123;
67 static const ResultCode testResultCode = static_cast<ResultCode>(456);
68 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
69
70 auto messenger = MakeShared<MockIExecutorMessenger>();
71 ASSERT_NE(messenger, nullptr);
72 EXPECT_CALL(*messenger, Finish(_, _, _))
73 .Times(Exactly(1))
__anon3f5d7b950102(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 74 .WillOnce([](uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) {
75 EXPECT_EQ(scheduleId, testScheduleId);
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<AbandonCommand>(executor, testScheduleId, attr, messenger);
89 ASSERT_NE(command, nullptr);
90 command->OnResult(testResultCode, testExtraInfo);
91 }
92
93 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_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))
__anon3f5d7b950202(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 103 .WillOnce([](uint64_t scheduleId, 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<AbandonCommand>(executor, testScheduleId, attr, messenger);
111 ASSERT_NE(command, nullptr);
112 command->OnResult(testResultCode, testExtraInfo);
113 }
114
115 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_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))
__anon3f5d7b950302(uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) 125 .WillOnce([](uint64_t scheduleId, int32_t resultCode, const Attributes &finalResult) {
126 EXPECT_EQ(scheduleId, testScheduleId);
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<AbandonCommand>(executor, testScheduleId, attr, messenger);
140 ASSERT_NE(command, nullptr);
141 command->OnResult(testResultCode);
142 }
143
144 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_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<AbandonCommand>(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(AbandonCommandUnitTest, AbandonCommand_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))
__anon3f5d7b950402(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 173 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) {
174 EXPECT_EQ(scheduleId, testScheduleId);
175 EXPECT_EQ(dstRole, SCHEDULER);
176 EXPECT_NE(msg, nullptr);
177 std::vector<uint8_t> extraInfo;
178 return USERAUTH_SUCCESS;
179 });
180 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
181 ASSERT_NE(executor, nullptr);
182 Attributes attr;
183 auto command = Common::MakeShared<AbandonCommand>(executor, testScheduleId, attr, messenger);
184 ASSERT_NE(command, nullptr);
185 command->OnAcquireInfo(testAcquire, testExtraInfo);
186 }
187
188 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_OnAcquireInfoTest_002, TestSize.Level0)
189 {
190 static const uint64_t testScheduleId = 123;
191 static const uint64_t testAcquire = 456;
192 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
193
194 auto messenger = MakeShared<MockIExecutorMessenger>();
195 ASSERT_NE(messenger, nullptr);
196 EXPECT_CALL(*messenger, SendData(_, _, _))
197 .Times(Exactly(1))
198 .WillOnce([](uint64_t scheduleId, ExecutorRole dstRole,
__anon3f5d7b950502(uint64_t scheduleId, ExecutorRole dstRole, const std::shared_ptr<AuthMessage> &msg) 199 const std::shared_ptr<AuthMessage> &msg) { return USERAUTH_ERROR; });
200 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
201 ASSERT_NE(executor, nullptr);
202 Attributes attr;
203 auto command = Common::MakeShared<AbandonCommand>(executor, testScheduleId, attr, messenger);
204 ASSERT_NE(command, nullptr);
205 command->OnAcquireInfo(testAcquire, testExtraInfo);
206 }
207
208 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_OnAcquireInfoTest_003, TestSize.Level0)
209 {
210 static const uint64_t testScheduleId = 123;
211 static const uint64_t testAcquire = 456;
212 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
213
214 auto messenger = MakeShared<MockIExecutorMessenger>();
215 ASSERT_NE(messenger, nullptr);
216 EXPECT_CALL(*messenger, SendData(_, _, _))
217 .Times(Exactly(3))
__anon3f5d7b950602(uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) 218 .WillOnce([](uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) {
219 return USERAUTH_SUCCESS;
220 })
__anon3f5d7b950702(uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) 221 .WillOnce([](uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) {
222 return USERAUTH_ERROR;
223 })
__anon3f5d7b950802(uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) 224 .WillOnce([](uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) {
225 return USERAUTH_SUCCESS;
226 });
227 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
228 ASSERT_NE(executor, nullptr);
229 Attributes attr;
230 auto command = Common::MakeShared<AbandonCommand>(executor, testScheduleId, attr, messenger);
231 ASSERT_NE(command, nullptr);
232 command->OnAcquireInfo(testAcquire, testExtraInfo);
233 command->OnAcquireInfo(testAcquire, testExtraInfo);
234 command->OnAcquireInfo(testAcquire, testExtraInfo);
235 }
236
237 HWTEST_F(AbandonCommandUnitTest, AbandonCommand_MixTest_003, TestSize.Level0)
238 {
239 static const uint64_t testScheduleId = 123;
240 static const uint64_t testAcquire = 456;
241 static const ResultCode testResultCode = static_cast<ResultCode>(456);
242 static const std::vector<uint8_t> testExtraInfo = {7, 8, 9};
243
244 auto messenger = MakeShared<MockIExecutorMessenger>();
245 ASSERT_NE(messenger, nullptr);
246 EXPECT_CALL(*messenger, Finish(_, _, _)).Times(Exactly(1));
247 EXPECT_CALL(*messenger, SendData(_, _, _))
248 .Times(Exactly(3))
249 .WillRepeatedly([](uint64_t scheduleId, int32_t dstType,
__anon3f5d7b950902(uint64_t scheduleId, int32_t dstType, std::shared_ptr<AuthMessage> msg) 250 std::shared_ptr<AuthMessage> msg) { return USERAUTH_SUCCESS; });
251 auto executor = Common::MakeShared<Executor>(nullptr, nullptr, 3);
252 ASSERT_NE(executor, nullptr);
253 Attributes attr;
254 auto command = Common::MakeShared<AbandonCommand>(executor, testScheduleId, attr, messenger);
255 ASSERT_NE(command, nullptr);
256 command->OnAcquireInfo(testAcquire, testExtraInfo);
257 command->OnAcquireInfo(testAcquire, testExtraInfo);
258 command->OnAcquireInfo(testAcquire, testExtraInfo);
259 command->OnResult(testResultCode);
260 command->OnAcquireInfo(testAcquire, testExtraInfo);
261 command->OnResult(testResultCode);
262 command->OnAcquireInfo(testAcquire, testExtraInfo);
263 command->OnAcquireInfo(testAcquire, testExtraInfo);
264 }
265 } // namespace UserAuth
266 } // namespace UserIam
267 } // namespace OHOS
268