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