1 /*
2  * Copyright (C) 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 #include "user_idm_database_test.h"
16 
17 #include "mock_iuser_auth_interface.h"
18 #include "user_idm_database_impl.h"
19 namespace OHOS {
20 namespace UserIam {
21 namespace UserAuth {
22 using namespace testing;
23 using namespace testing::ext;
SetUpTestCase()24 void UserIdmDatabaseTest::SetUpTestCase()
25 {
26 }
27 
TearDownTestCase()28 void UserIdmDatabaseTest::TearDownTestCase()
29 {
30 }
31 
SetUp()32 void UserIdmDatabaseTest::SetUp()
33 {
34     MockIUserAuthInterface::Holder::GetInstance().Reset();
35 }
36 
TearDown()37 void UserIdmDatabaseTest::TearDown()
38 {
39     MockIUserAuthInterface::Holder::GetInstance().Reset();
40 }
41 
42 HWTEST_F(UserIdmDatabaseTest, FailedGetSecUserInfo, TestSize.Level0)
43 {
44     auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
45     EXPECT_CALL(*mock, GetUserInfo(_, _, _, _)).WillRepeatedly(Return(1));
46     auto &database = UserIdmDatabase::Instance();
47     constexpr int32_t USER_ID = 100;
48     std::shared_ptr<SecureUserInfoInterface> secUserInfo = nullptr;
49     database.GetSecUserInfo(USER_ID, secUserInfo);
50     EXPECT_EQ(secUserInfo, nullptr);
51 }
52 
53 HWTEST_F(UserIdmDatabaseTest, FailedGetSecUserInfoNoPin, TestSize.Level0)
54 {
55     auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
56     constexpr int32_t USER_ID = 100;
57     constexpr uint64_t SECURE_UID = 200;
__anon5438c4200102(std::vector<HdiEnrolledInfo> &list) 58     auto fillUpInfos = [](std::vector<HdiEnrolledInfo> &list) {
59         std::vector<HdiEnrolledInfo> infos = {};
60         HdiEnrolledInfo info1 = {
61             .enrolledId = 0,
62             .authType = static_cast<HdiAuthType>(2),
63         };
64         infos.emplace_back((info1));
65         list.swap(infos);
66     };
67 
68     EXPECT_CALL(*mock, GetUserInfo(USER_ID, _, _, _))
69         .WillRepeatedly(DoAll(SetArgReferee<1>(SECURE_UID), WithArg<3>(fillUpInfos), Return(0)));
70 
71     auto &database = UserIdmDatabase::Instance();
72     std::shared_ptr<SecureUserInfoInterface> secUserInfo = nullptr;
73     database.GetSecUserInfo(USER_ID, secUserInfo);
74 
75     EXPECT_NE(secUserInfo, nullptr);
76 }
77 
78 HWTEST_F(UserIdmDatabaseTest, FailedGetSecUserInfoNoEnrolledInfo, TestSize.Level0)
79 {
80     auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
81     constexpr int32_t USER_ID = 100;
82     constexpr uint64_t SECURE_UID = 200;
__anon5438c4200202(std::vector<HdiEnrolledInfo> &list) 83     auto fillUpInfos = [](std::vector<HdiEnrolledInfo> &list) {
84         std::vector<HdiEnrolledInfo> infos = {};
85         list.swap(infos);
86     };
87 
88     EXPECT_CALL(*mock, GetUserInfo(USER_ID, _, _, _))
89         .WillRepeatedly(DoAll(SetArgReferee<1>(SECURE_UID), WithArg<3>(fillUpInfos), Return(0)));
90 
91     std::shared_ptr<SecureUserInfoInterface> secUserInfo = nullptr;
92     UserIdmDatabase::Instance().GetSecUserInfo(USER_ID, secUserInfo);
93 
94     // test EnrolledInfo is null
95     EXPECT_NE(secUserInfo, nullptr);
96 }
97 
98 HWTEST_F(UserIdmDatabaseTest, SuccessfulGetSecUserInfo, TestSize.Level0)
99 {
100     auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
101     constexpr int32_t USER_ID = 100;
102     constexpr uint64_t SECURE_UID = 200;
103     constexpr PinSubType PIN_SUB_TYPE = PIN_NUMBER;
__anon5438c4200302(std::vector<HdiEnrolledInfo> &list) 104     auto fillUpInfos = [](std::vector<HdiEnrolledInfo> &list) {
105         std::vector<HdiEnrolledInfo> infos = {};
106         HdiEnrolledInfo info1 = {
107             .enrolledId = 0,
108             .authType = static_cast<HdiAuthType>(1),
109         };
110         infos.emplace_back((info1));
111         HdiEnrolledInfo info2 = {
112             .enrolledId = 1,
113             .authType = static_cast<HdiAuthType>(2),
114         };
115         infos.emplace_back((info2));
116         list.swap(infos);
117     };
118 
119     EXPECT_CALL(*mock, GetUserInfo(USER_ID, _, _, _))
120         .WillRepeatedly(DoAll(SetArgReferee<1>(SECURE_UID), SetArgReferee<2>(static_cast<HdiPinSubType>(PIN_SUB_TYPE)),
121             WithArg<3>(fillUpInfos), Return(0)));
122 
123     auto &database = UserIdmDatabase::Instance();
124     std::shared_ptr<SecureUserInfoInterface> secUserInfo = nullptr;
125     database.GetSecUserInfo(USER_ID, secUserInfo);
126     EXPECT_NE(secUserInfo, nullptr);
127     EXPECT_EQ(USER_ID, secUserInfo->GetUserId());
128     EXPECT_EQ(SECURE_UID, secUserInfo->GetSecUserId());
129     EXPECT_EQ(2U, secUserInfo->GetEnrolledInfo().size());
130 }
131 
132 HWTEST_F(UserIdmDatabaseTest, FailedGetCredentialInfoVector, TestSize.Level0)
133 {
134     auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
135     // mock hdi interface return 1
136     constexpr int32_t USER_ID = 100;
137     AuthType authType = PIN;
138     EXPECT_CALL(*mock, GetCredential(_, _, _)).WillRepeatedly(Return(1));
139     auto &database = UserIdmDatabase::Instance();
140     std::vector<std::shared_ptr<CredentialInfoInterface>> infoRet = {};
141     database.GetCredentialInfo(USER_ID, authType, infoRet);
142     EXPECT_EQ(infoRet.size(), 0U);
143 }
144 
145 HWTEST_F(UserIdmDatabaseTest, SuccessfulGetCredentialInfoVector, TestSize.Level0)
146 {
147     auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
148     constexpr int32_t USER_ID = 100;
149     HdiAuthType authType = HdiAuthType::PIN;
150     // mock hdi interface return 0
__anon5438c4200402(std::vector<HdiCredentialInfo> &list) 151     auto fillUpInfos = [](std::vector<HdiCredentialInfo> &list) {
152         std::vector<HdiCredentialInfo> infos = {};
153         HdiCredentialInfo temp1 = {
154             .credentialId = 1,
155             .executorIndex = 2,
156             .templateId = 3,
157             .authType = static_cast<HdiAuthType>(1),
158             .executorMatcher = 2,
159             .executorSensorHint = 3,
160         };
161         infos.push_back(temp1);
162         HdiCredentialInfo temp2 = {
163             .credentialId = 2,
164             .executorIndex = 3,
165             .templateId = 4,
166             .authType = static_cast<HdiAuthType>(1),
167             .executorMatcher = 3,
168             .executorSensorHint = 2,
169         };
170         infos.push_back(temp2);
171         list.swap(infos);
172     };
173     EXPECT_CALL(*mock, GetCredential(USER_ID, authType, _)).WillRepeatedly(DoAll(WithArg<2>(fillUpInfos), Return(0)));
174     auto &database = UserIdmDatabase::Instance();
175     AuthType authType1 = PIN;
176     std::vector<std::shared_ptr<CredentialInfoInterface>> info = {};
177     database.GetCredentialInfo(USER_ID, authType1, info);
178 
179     // test return result
180     EXPECT_EQ(info.size(), 2U);
181 
182     // test temp1
183     EXPECT_EQ(USER_ID, info[0]->GetUserId());
184     EXPECT_EQ(1U, info[0]->GetCredentialId());
185     EXPECT_EQ(2U, info[0]->GetExecutorIndex());
186     EXPECT_EQ(3U, info[0]->GetTemplateId());
187     EXPECT_EQ(static_cast<AuthType>(1), info[0]->GetAuthType());
188     EXPECT_EQ(3U, info[0]->GetExecutorSensorHint());
189     EXPECT_EQ(2U, info[0]->GetExecutorMatcher());
190 
191     // test temp2
192     EXPECT_EQ(USER_ID, info[1]->GetUserId());
193     EXPECT_EQ(2U, info[1]->GetCredentialId());
194     EXPECT_EQ(3U, info[1]->GetExecutorIndex());
195     EXPECT_EQ(4U, info[1]->GetTemplateId());
196     EXPECT_EQ(static_cast<AuthType>(1), info[1]->GetAuthType());
197     EXPECT_EQ(2U, info[1]->GetExecutorSensorHint());
198     EXPECT_EQ(3U, info[1]->GetExecutorMatcher());
199 }
200 
201 HWTEST_F(UserIdmDatabaseTest, DeleteCredentialInfo001, TestSize.Level0)
202 {
203     int32_t testUserId = 4501;
204     uint64_t testCredentialId = 87841;
205     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
206     std::shared_ptr<CredentialInfoInterface> testCredInfo = nullptr;
207 
208     auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
209     EXPECT_NE(mockHdi, nullptr);
210     EXPECT_CALL(*mockHdi, DeleteCredential(_, _, _, _)).WillRepeatedly(Return(1));
211     int32_t result = UserIdmDatabase::Instance().DeleteCredentialInfo(testUserId, testCredentialId,
212         testAuthToken, testCredInfo);
213     EXPECT_EQ(result, 1);
214 }
215 
216 HWTEST_F(UserIdmDatabaseTest, DeleteCredentialInfo002, TestSize.Level0)
217 {
218     int32_t testUserId = 4501;
219     uint64_t testCredentialId = 87841;
220     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
221     std::shared_ptr<CredentialInfoInterface> testCredInfo = nullptr;
222 
223     auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
224     EXPECT_NE(mockHdi, nullptr);
225     EXPECT_CALL(*mockHdi, DeleteCredential(_, _, _, _)).Times(1);
226     ON_CALL(*mockHdi, DeleteCredential)
227         .WillByDefault(
__anon5438c4200502(int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, HdiCredentialInfo &info) 228             [](int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, HdiCredentialInfo &info) {
229                 info.authType = static_cast<HdiAuthType>(1);
230                 info.credentialId = 10;
231                 info.executorIndex = 20;
232                 info.executorMatcher = 30;
233                 info.executorSensorHint = 40;
234                 info.templateId = 50;
235                 return HDF_SUCCESS;
236             }
237         );
238     int32_t result = UserIdmDatabase::Instance().DeleteCredentialInfo(testUserId, testCredentialId,
239         testAuthToken, testCredInfo);
240     EXPECT_EQ(result, SUCCESS);
241     EXPECT_NE(testCredInfo, nullptr);
242     EXPECT_EQ(testCredInfo->GetAuthType(), PIN);
243     EXPECT_EQ(testCredInfo->GetCredentialId(), 10);
244     EXPECT_EQ(testCredInfo->GetExecutorIndex(), 20);
245     EXPECT_EQ(testCredInfo->GetExecutorMatcher(), 30);
246     EXPECT_EQ(testCredInfo->GetExecutorSensorHint(), 40);
247     EXPECT_EQ(testCredInfo->GetTemplateId(), 50);
248     EXPECT_EQ(testCredInfo->GetUserId(), testUserId);
249 }
250 
251 HWTEST_F(UserIdmDatabaseTest, DeleteUser001, TestSize.Level0)
252 {
253     int32_t testUserId = 4501;
254     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
255     std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
256     std::vector<uint8_t> rootSecret;
257 
258     auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
259     EXPECT_NE(mockHdi, nullptr);
260     EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _)).WillRepeatedly(Return(1));
261     int32_t result = UserIdmDatabase::Instance().DeleteUser(testUserId, testAuthToken, testCredInfos, rootSecret);
262     EXPECT_EQ(result, 1);
263 }
264 
265 HWTEST_F(UserIdmDatabaseTest, DeleteUser002, TestSize.Level0)
266 {
267     int32_t testUserId = 4501;
268     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
269     std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
270     std::vector<uint8_t> testRootSecret;
271 
272     auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
273     EXPECT_NE(mockHdi, nullptr);
274     EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _)).Times(1);
275     ON_CALL(*mockHdi, DeleteUser)
276         .WillByDefault([](int32_t userId, const std::vector<uint8_t> &authToken,
__anon5438c4200602(int32_t userId, const std::vector<uint8_t> &authToken, std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) 277             std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) {
278                 HdiCredentialInfo info = {};
279                 info.authType = static_cast<HdiAuthType>(1);
280                 info.credentialId = 10;
281                 info.executorIndex = 20;
282                 info.executorMatcher = 30;
283                 info.executorSensorHint = 40;
284                 info.templateId = 50;
285                 deletedInfos.emplace_back(info);
286                 rootSecret = {1, 2, 3};
287                 return HDF_SUCCESS;
288             }
289         );
290     int32_t result = UserIdmDatabase::Instance().DeleteUser(testUserId, testAuthToken, testCredInfos, testRootSecret);
291     EXPECT_EQ(result, SUCCESS);
292     EXPECT_EQ(testCredInfos.size(), 1);
293     EXPECT_NE(testCredInfos[0], nullptr);
294     EXPECT_EQ(testCredInfos[0]->GetAuthType(), PIN);
295     EXPECT_EQ(testCredInfos[0]->GetCredentialId(), 10);
296     EXPECT_EQ(testCredInfos[0]->GetExecutorIndex(), 20);
297     EXPECT_EQ(testCredInfos[0]->GetExecutorMatcher(), 30);
298     EXPECT_EQ(testCredInfos[0]->GetExecutorSensorHint(), 40);
299     EXPECT_EQ(testCredInfos[0]->GetTemplateId(), 50);
300     EXPECT_EQ(testCredInfos[0]->GetUserId(), testUserId);
301     EXPECT_THAT(testRootSecret, ElementsAre(1, 2, 3));
302 }
303 
304 HWTEST_F(UserIdmDatabaseTest, DeleteUserEnforce001, TestSize.Level0)
305 {
306     int32_t testUserId = 4501;
307     std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
308 
309     auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
310     EXPECT_NE(mockHdi, nullptr);
311     EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _)).WillRepeatedly(Return(1));
312     int32_t result = UserIdmDatabase::Instance().DeleteUserEnforce(testUserId, testCredInfos);
313     EXPECT_EQ(result, 1);
314 }
315 
316 HWTEST_F(UserIdmDatabaseTest, DeleteUserEnforce002, TestSize.Level0)
317 {
318     int32_t testUserId = 4501;
319     std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
320 
321     auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
322     EXPECT_NE(mockHdi, nullptr);
323     EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _)).Times(1);
324     ON_CALL(*mockHdi, EnforceDeleteUser)
325         .WillByDefault(
__anon5438c4200702(int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) 326             [](int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) {
327                 HdiCredentialInfo info = {};
328                 info.authType = static_cast<HdiAuthType>(1);
329                 info.credentialId = 10;
330                 info.executorIndex = 20;
331                 info.executorMatcher = 30;
332                 info.executorSensorHint = 40;
333                 info.templateId = 50;
334                 deletedInfos.emplace_back(info);
335                 return HDF_SUCCESS;
336             }
337         );
338     int32_t result = UserIdmDatabase::Instance().DeleteUserEnforce(testUserId, testCredInfos);
339     EXPECT_EQ(result, SUCCESS);
340     EXPECT_EQ(testCredInfos.size(), 1);
341     EXPECT_NE(testCredInfos[0], nullptr);
342     EXPECT_EQ(testCredInfos[0]->GetAuthType(), PIN);
343     EXPECT_EQ(testCredInfos[0]->GetCredentialId(), 10);
344     EXPECT_EQ(testCredInfos[0]->GetExecutorIndex(), 20);
345     EXPECT_EQ(testCredInfos[0]->GetExecutorMatcher(), 30);
346     EXPECT_EQ(testCredInfos[0]->GetExecutorSensorHint(), 40);
347     EXPECT_EQ(testCredInfos[0]->GetTemplateId(), 50);
348     EXPECT_EQ(testCredInfos[0]->GetUserId(), testUserId);
349 }
350 } // namespace UserAuth
351 } // namespace UserIam
352 } // namespace OHOS