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;
__anon41d6c9e80102(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;
__anon41d6c9e80202(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;
__anon41d6c9e80302(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(PIN_SUB_TYPE, secUserInfo->GetPinSubType());
130 EXPECT_EQ(2U, secUserInfo->GetEnrolledInfo().size());
131 }
132
133 HWTEST_F(UserIdmDatabaseTest, FailedGetCredentialInfoVector, TestSize.Level0)
134 {
135 auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
136 // mock hdi interface return 1
137 constexpr int32_t USER_ID = 100;
138 AuthType authType = PIN;
139 EXPECT_CALL(*mock, GetCredential(_, _, _)).WillRepeatedly(Return(1));
140 auto &database = UserIdmDatabase::Instance();
141 std::vector<std::shared_ptr<CredentialInfoInterface>> infoRet = {};
142 database.GetCredentialInfo(USER_ID, authType, infoRet);
143 EXPECT_EQ(infoRet.size(), 0U);
144 }
145
146 HWTEST_F(UserIdmDatabaseTest, SuccessfulGetCredentialInfoVector, TestSize.Level0)
147 {
148 auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
149 constexpr int32_t USER_ID = 100;
150 HdiAuthType authType = HdiAuthType::PIN;
151 // mock hdi interface return 0
__anon41d6c9e80402(std::vector<HdiCredentialInfo> &list) 152 auto fillUpInfos = [](std::vector<HdiCredentialInfo> &list) {
153 std::vector<HdiCredentialInfo> infos = {};
154 HdiCredentialInfo temp1 = {
155 .credentialId = 1,
156 .executorIndex = 2,
157 .templateId = 3,
158 .authType = static_cast<HdiAuthType>(1),
159 .executorMatcher = 2,
160 .executorSensorHint = 3,
161 };
162 infos.push_back(temp1);
163 HdiCredentialInfo temp2 = {
164 .credentialId = 2,
165 .executorIndex = 3,
166 .templateId = 4,
167 .authType = static_cast<HdiAuthType>(1),
168 .executorMatcher = 3,
169 .executorSensorHint = 2,
170 };
171 infos.push_back(temp2);
172 list.swap(infos);
173 };
174 EXPECT_CALL(*mock, GetCredential(USER_ID, authType, _)).WillRepeatedly(DoAll(WithArg<2>(fillUpInfos), Return(0)));
175 auto &database = UserIdmDatabase::Instance();
176 AuthType authType1 = PIN;
177 std::vector<std::shared_ptr<CredentialInfoInterface>> info = {};
178 database.GetCredentialInfo(USER_ID, authType1, info);
179
180 // test return result
181 EXPECT_EQ(info.size(), 2U);
182
183 // test temp1
184 EXPECT_EQ(USER_ID, info[0]->GetUserId());
185 EXPECT_EQ(1U, info[0]->GetCredentialId());
186 EXPECT_EQ(2U, info[0]->GetExecutorIndex());
187 EXPECT_EQ(3U, info[0]->GetTemplateId());
188 EXPECT_EQ(static_cast<AuthType>(1), info[0]->GetAuthType());
189 EXPECT_EQ(3U, info[0]->GetExecutorSensorHint());
190 EXPECT_EQ(2U, info[0]->GetExecutorMatcher());
191
192 // test temp2
193 EXPECT_EQ(USER_ID, info[1]->GetUserId());
194 EXPECT_EQ(2U, info[1]->GetCredentialId());
195 EXPECT_EQ(3U, info[1]->GetExecutorIndex());
196 EXPECT_EQ(4U, info[1]->GetTemplateId());
197 EXPECT_EQ(static_cast<AuthType>(1), info[1]->GetAuthType());
198 EXPECT_EQ(2U, info[1]->GetExecutorSensorHint());
199 EXPECT_EQ(3U, info[1]->GetExecutorMatcher());
200 }
201
202 HWTEST_F(UserIdmDatabaseTest, DeleteCredentialInfo001, TestSize.Level0)
203 {
204 int32_t testUserId = 4501;
205 uint64_t testCredentialId = 87841;
206 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
207 std::shared_ptr<CredentialInfoInterface> testCredInfo = nullptr;
208
209 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
210 EXPECT_NE(mockHdi, nullptr);
211 EXPECT_CALL(*mockHdi, DeleteCredential(_, _, _, _)).WillRepeatedly(Return(1));
212 int32_t result = UserIdmDatabase::Instance().DeleteCredentialInfo(testUserId, testCredentialId,
213 testAuthToken, testCredInfo);
214 EXPECT_EQ(result, 1);
215 }
216
217 HWTEST_F(UserIdmDatabaseTest, DeleteCredentialInfo002, TestSize.Level0)
218 {
219 int32_t testUserId = 4501;
220 uint64_t testCredentialId = 87841;
221 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
222 std::shared_ptr<CredentialInfoInterface> testCredInfo = nullptr;
223
224 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
225 EXPECT_NE(mockHdi, nullptr);
226 EXPECT_CALL(*mockHdi, DeleteCredential(_, _, _, _)).Times(1);
227 ON_CALL(*mockHdi, DeleteCredential)
228 .WillByDefault(
__anon41d6c9e80502(int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, HdiCredentialInfo &info) 229 [](int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, HdiCredentialInfo &info) {
230 info.authType = static_cast<HdiAuthType>(1);
231 info.credentialId = 10;
232 info.executorIndex = 20;
233 info.executorMatcher = 30;
234 info.executorSensorHint = 40;
235 info.templateId = 50;
236 return HDF_SUCCESS;
237 }
238 );
239 int32_t result = UserIdmDatabase::Instance().DeleteCredentialInfo(testUserId, testCredentialId,
240 testAuthToken, testCredInfo);
241 EXPECT_EQ(result, SUCCESS);
242 EXPECT_NE(testCredInfo, nullptr);
243 EXPECT_EQ(testCredInfo->GetAuthType(), PIN);
244 EXPECT_EQ(testCredInfo->GetCredentialId(), 10);
245 EXPECT_EQ(testCredInfo->GetExecutorIndex(), 20);
246 EXPECT_EQ(testCredInfo->GetExecutorMatcher(), 30);
247 EXPECT_EQ(testCredInfo->GetExecutorSensorHint(), 40);
248 EXPECT_EQ(testCredInfo->GetTemplateId(), 50);
249 EXPECT_EQ(testCredInfo->GetUserId(), testUserId);
250 }
251
252 HWTEST_F(UserIdmDatabaseTest, DeleteUser001, TestSize.Level0)
253 {
254 int32_t testUserId = 4501;
255 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
256 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
257 std::vector<uint8_t> rootSecret;
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, rootSecret);
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<CredentialInfoInterface>> testCredInfos;
271 std::vector<uint8_t> testRootSecret;
272
273 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
274 EXPECT_NE(mockHdi, nullptr);
275 EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _)).Times(1);
276 ON_CALL(*mockHdi, DeleteUser)
277 .WillByDefault([](int32_t userId, const std::vector<uint8_t> &authToken,
__anon41d6c9e80602(int32_t userId, const std::vector<uint8_t> &authToken, std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) 278 std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) {
279 HdiCredentialInfo info = {};
280 info.authType = static_cast<HdiAuthType>(1);
281 info.credentialId = 10;
282 info.executorIndex = 20;
283 info.executorMatcher = 30;
284 info.executorSensorHint = 40;
285 info.templateId = 50;
286 deletedInfos.emplace_back(info);
287 rootSecret = {1, 2, 3};
288 return HDF_SUCCESS;
289 }
290 );
291 int32_t result = UserIdmDatabase::Instance().DeleteUser(testUserId, testAuthToken, testCredInfos, testRootSecret);
292 EXPECT_EQ(result, SUCCESS);
293 EXPECT_EQ(testCredInfos.size(), 1);
294 EXPECT_NE(testCredInfos[0], nullptr);
295 EXPECT_EQ(testCredInfos[0]->GetAuthType(), PIN);
296 EXPECT_EQ(testCredInfos[0]->GetCredentialId(), 10);
297 EXPECT_EQ(testCredInfos[0]->GetExecutorIndex(), 20);
298 EXPECT_EQ(testCredInfos[0]->GetExecutorMatcher(), 30);
299 EXPECT_EQ(testCredInfos[0]->GetExecutorSensorHint(), 40);
300 EXPECT_EQ(testCredInfos[0]->GetTemplateId(), 50);
301 EXPECT_EQ(testCredInfos[0]->GetUserId(), testUserId);
302 EXPECT_THAT(testRootSecret, ElementsAre(1, 2, 3));
303 }
304
305 HWTEST_F(UserIdmDatabaseTest, DeleteUserEnforce001, TestSize.Level0)
306 {
307 int32_t testUserId = 4501;
308 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
309
310 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
311 EXPECT_NE(mockHdi, nullptr);
312 EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _)).WillRepeatedly(Return(1));
313 int32_t result = UserIdmDatabase::Instance().DeleteUserEnforce(testUserId, testCredInfos);
314 EXPECT_EQ(result, 1);
315 }
316
317 HWTEST_F(UserIdmDatabaseTest, DeleteUserEnforce002, TestSize.Level0)
318 {
319 int32_t testUserId = 4501;
320 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
321
322 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
323 EXPECT_NE(mockHdi, nullptr);
324 EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _)).Times(1);
325 ON_CALL(*mockHdi, EnforceDeleteUser)
326 .WillByDefault(
__anon41d6c9e80702(int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) 327 [](int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) {
328 HdiCredentialInfo info = {};
329 info.authType = static_cast<HdiAuthType>(1);
330 info.credentialId = 10;
331 info.executorIndex = 20;
332 info.executorMatcher = 30;
333 info.executorSensorHint = 40;
334 info.templateId = 50;
335 deletedInfos.emplace_back(info);
336 return HDF_SUCCESS;
337 }
338 );
339 int32_t result = UserIdmDatabase::Instance().DeleteUserEnforce(testUserId, testCredInfos);
340 EXPECT_EQ(result, SUCCESS);
341 EXPECT_EQ(testCredInfos.size(), 1);
342 EXPECT_NE(testCredInfos[0], nullptr);
343 EXPECT_EQ(testCredInfos[0]->GetAuthType(), PIN);
344 EXPECT_EQ(testCredInfos[0]->GetCredentialId(), 10);
345 EXPECT_EQ(testCredInfos[0]->GetExecutorIndex(), 20);
346 EXPECT_EQ(testCredInfos[0]->GetExecutorMatcher(), 30);
347 EXPECT_EQ(testCredInfos[0]->GetExecutorSensorHint(), 40);
348 EXPECT_EQ(testCredInfos[0]->GetTemplateId(), 50);
349 EXPECT_EQ(testCredInfos[0]->GetUserId(), testUserId);
350 }
351 } // namespace UserAuth
352 } // namespace UserIam
353 } // namespace OHOS