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;
__anon82e55c8a0102(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;
__anon82e55c8a0202(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_EQ(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;
__anon82e55c8a0302(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
__anon82e55c8a0402(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, DeleteUser001, TestSize.Level0)
202 {
203 int32_t testUserId = 4501;
204 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
205 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
206 std::vector<uint8_t> rootSecret;
207
208 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
209 EXPECT_NE(mockHdi, nullptr);
210 EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _)).WillRepeatedly(Return(1));
211 int32_t result = UserIdmDatabase::Instance().DeleteUser(testUserId, testAuthToken, testCredInfos, rootSecret);
212 EXPECT_EQ(result, 1);
213 }
214
215 HWTEST_F(UserIdmDatabaseTest, DeleteUser002, TestSize.Level0)
216 {
217 int32_t testUserId = 4501;
218 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
219 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
220 std::vector<uint8_t> testRootSecret;
221
222 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
223 EXPECT_NE(mockHdi, nullptr);
224 EXPECT_CALL(*mockHdi, DeleteUser(_, _, _, _)).Times(1);
225 ON_CALL(*mockHdi, DeleteUser)
226 .WillByDefault([](int32_t userId, const std::vector<uint8_t> &authToken,
__anon82e55c8a0502(int32_t userId, const std::vector<uint8_t> &authToken, std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) 227 std::vector<HdiCredentialInfo> &deletedInfos, std::vector<uint8_t> &rootSecret) {
228 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 deletedInfos.emplace_back(info);
236 rootSecret = {1, 2, 3};
237 return HDF_SUCCESS;
238 }
239 );
240 int32_t result = UserIdmDatabase::Instance().DeleteUser(testUserId, testAuthToken, testCredInfos, testRootSecret);
241 EXPECT_EQ(result, SUCCESS);
242 EXPECT_EQ(testCredInfos.size(), 1);
243 EXPECT_NE(testCredInfos[0], nullptr);
244 EXPECT_EQ(testCredInfos[0]->GetAuthType(), PIN);
245 EXPECT_EQ(testCredInfos[0]->GetCredentialId(), 10);
246 EXPECT_EQ(testCredInfos[0]->GetExecutorIndex(), 20);
247 EXPECT_EQ(testCredInfos[0]->GetExecutorMatcher(), 30);
248 EXPECT_EQ(testCredInfos[0]->GetExecutorSensorHint(), 40);
249 EXPECT_EQ(testCredInfos[0]->GetTemplateId(), 50);
250 EXPECT_EQ(testCredInfos[0]->GetUserId(), testUserId);
251 EXPECT_THAT(testRootSecret, ElementsAre(1, 2, 3));
252 }
253
254 HWTEST_F(UserIdmDatabaseTest, DeleteUserEnforce001, TestSize.Level0)
255 {
256 int32_t testUserId = 4501;
257 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
258
259 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
260 EXPECT_NE(mockHdi, nullptr);
261 EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _)).WillRepeatedly(Return(1));
262 int32_t result = UserIdmDatabase::Instance().DeleteUserEnforce(testUserId, testCredInfos);
263 EXPECT_EQ(result, 1);
264 }
265
266 HWTEST_F(UserIdmDatabaseTest, DeleteUserEnforce002, TestSize.Level0)
267 {
268 int32_t testUserId = 4501;
269 std::vector<std::shared_ptr<CredentialInfoInterface>> testCredInfos;
270
271 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
272 EXPECT_NE(mockHdi, nullptr);
273 EXPECT_CALL(*mockHdi, EnforceDeleteUser(_, _)).Times(1);
274 ON_CALL(*mockHdi, EnforceDeleteUser)
275 .WillByDefault(
__anon82e55c8a0602(int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) 276 [](int32_t userId, std::vector<HdiCredentialInfo> &deletedInfos) {
277 HdiCredentialInfo info = {};
278 info.authType = static_cast<HdiAuthType>(1);
279 info.credentialId = 10;
280 info.executorIndex = 20;
281 info.executorMatcher = 30;
282 info.executorSensorHint = 40;
283 info.templateId = 50;
284 deletedInfos.emplace_back(info);
285 return HDF_SUCCESS;
286 }
287 );
288 int32_t result = UserIdmDatabase::Instance().DeleteUserEnforce(testUserId, testCredInfos);
289 EXPECT_EQ(result, SUCCESS);
290 EXPECT_EQ(testCredInfos.size(), 1);
291 EXPECT_NE(testCredInfos[0], nullptr);
292 EXPECT_EQ(testCredInfos[0]->GetAuthType(), PIN);
293 EXPECT_EQ(testCredInfos[0]->GetCredentialId(), 10);
294 EXPECT_EQ(testCredInfos[0]->GetExecutorIndex(), 20);
295 EXPECT_EQ(testCredInfos[0]->GetExecutorMatcher(), 30);
296 EXPECT_EQ(testCredInfos[0]->GetExecutorSensorHint(), 40);
297 EXPECT_EQ(testCredInfos[0]->GetTemplateId(), 50);
298 EXPECT_EQ(testCredInfos[0]->GetUserId(), testUserId);
299 }
300 } // namespace UserAuth
301 } // namespace UserIam
302 } // namespace OHOS