1 /*
2  * Copyright (c) 2021-2024 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_logger.h"
19 #include "iam_ptr.h"
20 
21 #include "pin_auth_executor_callback_hdi.h"
22 #include "pin_auth_manager.h"
23 #include "iam_common_defines.h"
24 #include "mock_iall_in_one_executor.h"
25 #include "mock_icollector_executor.h"
26 #include "mock_iexecute_callback.h"
27 #include "mock_inputer_get_data.h"
28 
29 #define LOG_TAG "PIN_AUTH_SA"
30 
31 using namespace testing;
32 using namespace testing::ext;
33 using namespace OHOS::UserIam::UserAuth;
34 using namespace OHOS::UserIam::Common;
35 
36 namespace OHOS {
37 namespace UserIam {
38 namespace PinAuth {
39 using IamResultCode = OHOS::UserIam::UserAuth::ResultCode;
40 class PinAuthExecutorCallbackHdiUnitTest : public testing::Test {
41 public:
42     static void SetUpTestCase();
43     static void TearDownTestCase();
44     void SetUp();
45     void TearDown();
46 };
47 
SetUpTestCase()48 void PinAuthExecutorCallbackHdiUnitTest ::SetUpTestCase()
49 {
50 }
51 
TearDownTestCase()52 void PinAuthExecutorCallbackHdiUnitTest ::TearDownTestCase()
53 {
54 }
55 
SetUp()56 void PinAuthExecutorCallbackHdiUnitTest ::SetUp()
57 {
58 }
59 
TearDown()60 void PinAuthExecutorCallbackHdiUnitTest ::TearDown()
61 {
62 }
63 
64 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnGetData_005, TestSize.Level0)
65 {
66     auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
67     const uint32_t tempTokenId = 123;
68     const uint64_t tempScheduleId = 1;
69     const UserAuth::ExecutorParam executorParam = {
70         .tokenId = tempTokenId,
71         .authIntent = 0,
72         .scheduleId = tempScheduleId,
73     };
74     std::shared_ptr<PinAuthCollectorHdi> pinAuthCollectorHdi = MakeShared<PinAuthCollectorHdi>(nullptr);
75     std::vector<uint8_t> algoParameter = {1, 2, 3, 4, 5};
76     uint64_t authSubType = 0;
77     uint32_t algoVersion = 0;
78     std::vector<uint8_t> challenge = {1, 2, 3, 4, 5};
79     std::string pinComplexityReg = {};
80 
81     PinAuthExecutorCallbackHdi callbackHdi(
82         executeCallback, pinAuthCollectorHdi, executorParam, GET_DATA_MODE_COLLECTOR_PIN_AUTH);
83     sptr<InputerGetData> inputer(new (std::nothrow) MockInputerGetData());
84     callbackHdi.tokenId_ = tempTokenId;
85     PinAuthManager::GetInstance().pinAuthInputerMap_.emplace(tempTokenId, inputer);
86     callbackHdi.pinAuthAllInOneHdi_ = nullptr;
87     callbackHdi.pinAuthCollectorHdi_ = nullptr;
88     EXPECT_EQ(callbackHdi.OnGetData(algoParameter, authSubType, algoVersion, challenge, pinComplexityReg), HDF_FAILURE);
89 }
90 
91 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnGetData_004, TestSize.Level0)
92 {
93     auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
94     const uint32_t tempTokenId = 123;
95     const uint64_t tempScheduleId = 1;
96     const UserAuth::ExecutorParam executorParam = {
97         .tokenId = tempTokenId,
98         .authIntent = 0,
99         .scheduleId = tempScheduleId,
100     };
101     std::shared_ptr<PinAuthCollectorHdi> pinAuthCollectorHdi = MakeShared<PinAuthCollectorHdi>(nullptr);
102     std::vector<uint8_t> algoParameter = {1, 2, 3, 4, 5};
103     uint64_t authSubType = 0;
104     uint32_t algoVersion = 0;
105     std::vector<uint8_t> challenge = {1, 2, 3, 4, 5};
106     std::string pinComplexityReg = {};
107 
108     PinAuthExecutorCallbackHdi callbackHdi(
109         executeCallback, pinAuthCollectorHdi, executorParam, GET_DATA_MODE_COLLECTOR_PIN_AUTH);
110     sptr<InputerGetData> inputer(new (std::nothrow) MockInputerGetData());
111     callbackHdi.tokenId_ = tempTokenId;
112     PinAuthManager::GetInstance().pinAuthInputerMap_.emplace(tempTokenId, inputer);
113     EXPECT_EQ(callbackHdi.OnGetData(algoParameter, authSubType, algoVersion, challenge, pinComplexityReg), HDF_SUCCESS);
114 }
115 
116 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnGetData_003, TestSize.Level0)
117 {
118     auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
119     auto executorProxy = new (std::nothrow) MockIAllInOneExecutor();
120     std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(executorProxy);
121     const uint32_t tempTokenId = 123;
122     const uint64_t tempScheduleId = 1;
123     const UserAuth::ExecutorParam executorParam = {
124         .tokenId = tempTokenId,
125         .authIntent = 0,
126         .scheduleId = tempScheduleId,
127     };
128     PinAuthExecutorCallbackHdi callbackHdi(
129         executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
130     std::vector<uint8_t> algoParameter = {1, 2, 3, 4, 5};
131     uint64_t authSubType = 0;
132     uint32_t algoVersion = 0;
133     std::vector<uint8_t> challenge = {1, 2, 3, 4, 5};
134     std::string pinComplexityReg = {};
135 
136     sptr<InputerGetData> inputer(new (std::nothrow) MockInputerGetData());
137     callbackHdi.tokenId_ = tempTokenId;
138     PinAuthManager::GetInstance().pinAuthInputerMap_.emplace(tempTokenId, inputer);
139 
140     EXPECT_EQ(callbackHdi.OnGetData(algoParameter, authSubType, algoVersion, challenge, pinComplexityReg), HDF_SUCCESS);
141 }
142 
143 
144 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnGetData_002, TestSize.Level0)
145 {
146     uint32_t tokenId = 1;
147     sptr<InputerGetData> inputer(new (std::nothrow) MockInputerGetData());
148     PinAuthManager::GetInstance().RegisterInputer(tokenId, inputer);
149 
150     auto executorProxy = new (std::nothrow) MockIAllInOneExecutor();
151     std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(executorProxy);
152     const uint32_t tempTokenId = 123;
153     const uint64_t tempScheduleId = 1;
154     const UserAuth::ExecutorParam executorParam = {
155         .tokenId = tempTokenId,
156         .authIntent = 0,
157         .scheduleId = tempScheduleId,
158     };
159     auto executeCallback = MakeShared<MockIExecuteCallback>();
160     PinAuthExecutorCallbackHdi callbackHdi(
161         executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
162     callbackHdi.frameworkCallback_ = Common::MakeShared<MockIExecuteCallback>();
163     EXPECT_EQ(callbackHdi.ConvertResultCode(SYSTEM_ERROR_CODE_BEGIN), GENERAL_ERROR);
164 }
165 
166 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_ConvertResultCode_001, TestSize.Level0)
167 {
168     auto executorProxy = new (std::nothrow) MockIAllInOneExecutor();
169     std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(executorProxy);
170     const uint32_t tempTokenId = 123;
171     const uint64_t tempScheduleId = 1;
172     const UserAuth::ExecutorParam executorParam = {
173         .tokenId = tempTokenId,
174         .authIntent = 0,
175         .scheduleId = tempScheduleId,
176     };
177     auto executeCallback = MakeShared<MockIExecuteCallback>();
178     PinAuthExecutorCallbackHdi callbackHdi(
179         executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
180     callbackHdi.frameworkCallback_ = Common::MakeShared<MockIExecuteCallback>();
181     EXPECT_EQ(callbackHdi.ConvertResultCode(SYSTEM_ERROR_CODE_BEGIN), GENERAL_ERROR);
182 }
183 
184 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnMessage_001, TestSize.Level0)
185 {
186     auto executeCallback = MakeShared<MockIExecuteCallback>();
187     auto executorProxy = new (std::nothrow) MockIAllInOneExecutor();
188     std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(executorProxy);
189     const uint32_t tempTokenId = 123;
190     const uint64_t tempScheduleId = 1;
191     const UserAuth::ExecutorParam executorParam = {
192         .tokenId = tempTokenId,
193         .authIntent = 0,
194         .scheduleId = tempScheduleId,
195     };
196     PinAuthExecutorCallbackHdi callbackHdi(
197         executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
198     std::vector<uint8_t> msg = {1, 2, 3, 4, 5};
199     int32_t tip = 0;
200     callbackHdi.frameworkCallback_ = Common::MakeShared<MockIExecuteCallback>();
201     EXPECT_EQ(callbackHdi.OnMessage(tip, msg), HDF_SUCCESS);
202 }
203 
204 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnTip_001, TestSize.Level0)
205 {
206     auto executeCallback = MakeShared<MockIExecuteCallback>();
207     auto executorProxy = new (std::nothrow) MockIAllInOneExecutor();
208     std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(executorProxy);
209     const uint32_t tempTokenId = 123;
210     const uint64_t tempScheduleId = 1;
211     const UserAuth::ExecutorParam executorParam = {
212         .tokenId = tempTokenId,
213         .authIntent = 0,
214         .scheduleId = tempScheduleId,
215     };
216     PinAuthExecutorCallbackHdi callbackHdi(
217         executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
218     std::vector<uint8_t> extraInfo = {1, 2, 3, 4, 5};
219     int32_t tip = 0;
220     callbackHdi.frameworkCallback_ = Common::MakeShared<MockIExecuteCallback>();
221     EXPECT_EQ(callbackHdi.OnTip(tip, extraInfo), HDF_SUCCESS);
222 }
223 
224 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnGetData_001, TestSize.Level0)
225 {
226     auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
227     auto executorProxy = new (std::nothrow) MockIAllInOneExecutor();
228     std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(executorProxy);
229     const uint32_t tempTokenId = 123;
230     const uint64_t tempScheduleId = 1;
231     const UserAuth::ExecutorParam executorParam = {
232         .tokenId = tempTokenId,
233         .authIntent = 0,
234         .scheduleId = tempScheduleId,
235     };
236     PinAuthExecutorCallbackHdi callbackHdi(
237         executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
238     std::vector<uint8_t> algoParameter = {1, 2, 3, 4, 5};
239     uint64_t authSubType = 0;
240     uint32_t algoVersion = 0;
241     std::vector<uint8_t> challenge = {1, 2, 3, 4, 5};
242     std::string pinComplexityReg = {};
243     EXPECT_EQ(callbackHdi.OnGetData(algoParameter, authSubType, algoVersion, challenge, pinComplexityReg),
244         HDF_SUCCESS);
245 }
246 
247 HWTEST_F(PinAuthExecutorCallbackHdiUnitTest, PinAuthExecutorCallback_OnResult_001, TestSize.Level0)
248 {
249     static const std::map<ResultCode, IamResultCode> data = {{SUCCESS, IamResultCode::SUCCESS},
250         {FAIL, IamResultCode::FAIL}, {GENERAL_ERROR, IamResultCode::GENERAL_ERROR},
251         {CANCELED, IamResultCode::CANCELED}, {TIMEOUT, IamResultCode::TIMEOUT},
252         {BUSY, IamResultCode::BUSY},
253         {INVALID_PARAMETERS, IamResultCode::INVALID_PARAMETERS},
254         {LOCKED, IamResultCode::LOCKED}};
255 
256     for (const auto &pair : data) {
257         auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
258         ASSERT_TRUE(executeCallback != nullptr);
259         std::vector<uint8_t> testExtraInfo = {1, 2, 3, 4, 5, 6};
260         EXPECT_CALL(*executeCallback, OnResult(_, _))
261             .Times(Exactly(3))
__anona986cc410102(int32_t result, const std::vector<uint8_t> &extraInfo) 262             .WillRepeatedly([&pair, &testExtraInfo](int32_t result, const std::vector<uint8_t> &extraInfo) {
263                 EXPECT_TRUE(result == pair.second);
264                 EXPECT_TRUE(testExtraInfo.size() == extraInfo.size());
265                 EXPECT_TRUE(std::equal(extraInfo.begin(), extraInfo.end(), testExtraInfo.begin()));
266             });
267         std::shared_ptr<PinAuthAllInOneHdi> pinAuthAllInOneHdi = MakeShared<PinAuthAllInOneHdi>(nullptr);
268         const uint32_t tokenId = 123;
269         const uint64_t scheduleId = 1;
270         const UserAuth::ExecutorParam executorParam = {
271             .tokenId = tokenId,
272             .authIntent = 0,
273             .scheduleId = scheduleId,
274         };
275         PinAuthExecutorCallbackHdi callbackHdi1(
276             executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_AUTH);
277         callbackHdi1.OnResult(pair.first, testExtraInfo);
278         PinAuthExecutorCallbackHdi callbackHdi2(
279             executeCallback, pinAuthAllInOneHdi, executorParam, GET_DATA_MODE_ALL_IN_ONE_PIN_ENROLL);
280         callbackHdi2.OnResult(pair.first, testExtraInfo);
281         std::shared_ptr<PinAuthCollectorHdi> pinAuthCollectorHdi = MakeShared<PinAuthCollectorHdi>(nullptr);
282         PinAuthExecutorCallbackHdi callbackHdi3(
283             executeCallback, pinAuthCollectorHdi, executorParam, GET_DATA_MODE_COLLECTOR_PIN_AUTH);
284         callbackHdi2.OnResult(pair.first, testExtraInfo);
285     }
286 }
287 } // namespace PinAuth
288 } // namespace UserIam
289 } // namespace OHOS
290