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