1 /*
2 * Copyright (c) 2022-2025 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 <gmock/gmock.h>
17 #include "accesstoken_kit.h"
18 #define private public
19 #include "account_iam_client.h"
20 #undef private
21 #include "account_iam_client_test_callback.h"
22 #include "account_log_wrapper.h"
23 #include "account_iam_callback_service.h"
24 #ifdef PROXY_MOCK
25 #define private public
26 #include "account_iam_service.h"
27 #undef private
28 #endif
29 #include "account_test_common.h"
30 #include "account_i_a_m_proxy.h"
31 #include "token_setproc.h"
32 #include "iam_common_defines.h"
33 #include "ipc_skeleton.h"
34 #include "test_common.h"
35
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace OHOS::AccountSA;
39 using namespace OHOS::Security::AccessToken;
40 using namespace OHOS::UserIam::UserAuth;
41
42 static uint64_t g_selfTokenID = -1;
43 namespace OHOS {
44 namespace AccountTest {
45 namespace {
46 const int32_t TEST_USER_ID = 200;
47 const int32_t TEST_EXIST_ID = 100;
48 const int32_t DEFAULT_API_VERSION = 8;
49 const uint32_t INVALID_IPC_CODE = 1000;
50 const uint32_t INVALID_TOKEN_ID = 0;
51 const int32_t WAIT_TIME = 20;
52 const uint64_t TEST_CONTEXT_ID = 122;
53 const uint64_t TEST_CREDENTIAL_ID = 0;
54 const std::vector<uint8_t> TEST_CHALLENGE = {1, 2, 3, 4};
55
56 static PermissionDef INFO_MANAGER_TEST_PERM_DEF1 = {
57 .permissionName = "ohos.permission.open_door",
58 .bundleName = "account_iam_client_test",
59 .grantMode = 1,
60 .availableLevel = APL_NORMAL,
61 .provisionEnable = true,
62 .distributedSceneEnable = false,
63 .label = "label",
64 .labelId = 1,
65 .description = "open the door",
66 .descriptionId = 1
67 };
68
69 static PermissionDef INFO_MANAGER_TEST_PERM_DEF2 = {
70 .permissionName = "ohos.permission.break_door",
71 .bundleName = "account_iam_client_test",
72 .grantMode = 1,
73 .availableLevel = APL_NORMAL,
74 .provisionEnable = true,
75 .distributedSceneEnable = false,
76 .label = "label",
77 .labelId = 1,
78 .description = "break the door",
79 .descriptionId = 1
80 };
81
82 static PermissionStateFull INFO_MANAGER_TEST_STATE1 = {
83 .permissionName = "ohos.permission.open_door",
84 .isGeneral = true,
85 .resDeviceID = {"local"},
86 .grantStatus = {1},
87 .grantFlags = {1}
88 };
89
90 static PermissionStateFull INFO_MANAGER_TEST_STATE2 = {
91 .permissionName = "ohos.permission.open_door",
92 .isGeneral = true,
93 .resDeviceID = {"device 0", "device 1"},
94 .grantStatus = {1, 3},
95 .grantFlags = {1, 2}
96 };
97
98 static HapPolicyParams INFO_MANAGER_TEST_POLICY_PRAMS = {
99 .apl = APL_NORMAL,
100 .domain = "account_iam",
101 .permList = {INFO_MANAGER_TEST_PERM_DEF1, INFO_MANAGER_TEST_PERM_DEF2},
102 .permStateList = {INFO_MANAGER_TEST_STATE1, INFO_MANAGER_TEST_STATE2}
103 };
104
105 HapInfoParams infoManagerTestNormalInfoParms = {
106 .userID = 1,
107 .bundleName = "account_iam_client_test",
108 .instIndex = 0,
109 .appIDDesc = "test",
110 .apiVersion = DEFAULT_API_VERSION,
111 .isSystemApp = false
112 };
113
114 HapInfoParams infoManagerTestSystemInfoParms = {
115 .userID = 1,
116 .bundleName = "account_iam_client_test",
117 .instIndex = 0,
118 .appIDDesc = "test",
119 .apiVersion = DEFAULT_API_VERSION,
120 .isSystemApp = true
121 };
122 } // namespace
123
124 #ifdef HAS_PIN_AUTH_PART
125 class MockIInputer : public OHOS::AccountSA::IInputer {
126 public:
~MockIInputer()127 virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)128 void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
129 std::shared_ptr<IInputerData> inputerData) override
130 {
131 return;
132 }
133 };
134 #endif
135
136 class AccountIAMClientTest : public testing::Test {
137 public:
138 static void SetUpTestCase(void);
139 static void TearDownTestCase(void);
140 void SetUp(void) override;
141 void TearDown(void) override;
142 };
143
144 class CheckResultGetSetPropCallback final : public AccountSA::GetSetPropCallback {
145 public:
OnResult(int32_t result,const Attributes & extraInfo)146 void OnResult(int32_t result, const Attributes &extraInfo)
147 {
148 code_ = result;
149 }
GetResult()150 int GetResult()
151 {
152 if (code_ != ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR) {
153 return ERR_OK;
154 }
155 return code_;
156 }
157
158 private:
159 int code_;
160 };
161
162 class CheckResultIDMCallback final : public AccountSA::IDMCallback {
163 public:
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)164 void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo)
165 {
166 return;
167 }
OnResult(int32_t result,const Attributes & extraInfo)168 void OnResult(int32_t result, const Attributes &extraInfo)
169 {
170 code_ = result;
171 }
GetResult()172 int GetResult()
173 {
174 if (code_ != ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR) {
175 return ERR_OK;
176 }
177 return code_;
178 }
179
180 private:
181 int code_;
182 };
183
184 class TestOnEnrolledIdCallback final : public AccountSA::GetEnrolledIdCallback {
185 public:
OnEnrolledId(int32_t result,uint64_t enrolledId)186 void OnEnrolledId(int32_t result, uint64_t enrolledId)
187 {
188 code_ = result;
189 }
GetResult()190 int GetResult()
191 {
192 if (code_ != ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR) {
193 return ERR_OK;
194 }
195 return code_;
196 }
197
198 private:
199 int code_;
200 };
201
202 #ifdef HAS_PIN_AUTH_PART
203 class TestIInputer : public OHOS::AccountSA::IInputer {
204 public:
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)205 void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
206 std::shared_ptr<IInputerData> inputerData) override
207 {
208 if (inputerData != nullptr) {
209 inputerData->OnSetData(authSubType, {0, 0, 0, 0, 0, 0});
210 }
211 }
212
213 virtual ~TestIInputer() = default;
214 };
215 #endif
216
SetUpTestCase(void)217 void AccountIAMClientTest::SetUpTestCase(void)
218 {
219 ASSERT_TRUE(MockTokenId("accountmgr"));
220 g_selfTokenID = IPCSkeleton::GetSelfTokenID();
221 #ifdef PROXY_MOCK
222 sptr<IAccountIAM> service = new (std::nothrow) AccountIAMService();
223 ASSERT_NE(service, nullptr);
224 AccountIAMClient::GetInstance().proxy_ = new (std::nothrow) AccountIAMProxy(service->AsObject());
225 ASSERT_NE(AccountIAMClient::GetInstance().proxy_, nullptr);
226 #endif
227 }
228
TearDownTestCase(void)229 void AccountIAMClientTest::TearDownTestCase(void)
230 {}
231
SetUp(void)232 void AccountIAMClientTest::SetUp(void) __attribute__((no_sanitize("cfi")))
233 {
234 testing::UnitTest *test = testing::UnitTest::GetInstance();
235 ASSERT_NE(test, nullptr);
236 const testing::TestInfo *testinfo = test->current_test_info();
237 ASSERT_NE(testinfo, nullptr);
238 string testCaseName = string(testinfo->name());
239 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
240 }
241
TearDown(void)242 void AccountIAMClientTest::TearDown(void)
243 {}
244
Wait(const std::shared_ptr<TestGetSetPropCallback> & ptr)245 void Wait(const std::shared_ptr<TestGetSetPropCallback> &ptr)
246 {
247 std::unique_lock<std::mutex> lock(ptr->mutex);
248 ptr->cv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
249 [lockPtr = ptr]() { return lockPtr->isReady; });
250 }
251
Wait(const std::shared_ptr<TestIDMCallback> & ptr)252 void Wait(const std::shared_ptr<TestIDMCallback> &ptr)
253 {
254 std::unique_lock<std::mutex> lock(ptr->mutex);
255 ptr->cv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
256 [lockPtr = ptr]() { return lockPtr->isReady; });
257 }
258
259 /**
260 * @tc.name: AccountIAMClient_OpenSession_0100
261 * @tc.desc: Open Session.
262 * @tc.type: FUNC
263 * @tc.require: issueI5N90O
264 */
265 HWTEST_F(AccountIAMClientTest, AccountIAMClient_OpenSession_0100, TestSize.Level3)
266 {
267 std::vector<uint8_t> challenge;
268 AccountIAMClient::GetInstance().OpenSession(-1, challenge);
269 #ifdef PROXY_MOCK
270 EXPECT_FALSE(challenge.size() != 0);
271 #else // BUNDLE_ADAPTER_MOCK
272 EXPECT_TRUE(challenge.size() != 0);
273 #endif
274 AccountIAMClient::GetInstance().CloseSession(-1);
275 }
276
277 /**
278 * @tc.name: AccountIAMClient_AddCredential_0100
279 * @tc.desc: Add credential.
280 * @tc.type: FUNC
281 * @tc.require: issueI5N90O
282 */
283 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AddCredential_0100, TestSize.Level3)
284 {
285 CredentialParameters testPara = {};
286 auto callback = std::make_shared<MockIDMCallback>();
287 EXPECT_NE(callback, nullptr);
288 #ifdef PROXY_MOCK
289 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _)).Times(Exactly(1));
290 #else
291 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
292 #endif
293 auto testCallback = std::make_shared<TestIDMCallback>(callback);
294 EXPECT_NE(testCallback, nullptr);
295 AccountIAMClient::GetInstance().AddCredential(TEST_EXIST_ID, testPara, testCallback);
296 #ifndef PROXY_MOCK
297 std::unique_lock<std::mutex> lock(testCallback->mutex);
298 testCallback->cv.wait_for(
__anon36e93b360402() 299 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
300 #endif
301 }
302
303 /**
304 * @tc.name: AccountIAMClient_AddCredential_0200
305 * @tc.desc: Add credential.
306 * @tc.type: FUNC
307 * @tc.require: issueI5N90O
308 */
309 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AddCredential_0200, TestSize.Level3)
310 {
311 CredentialParameters testPara = {};
312 testPara.authType = AuthType::PIN;
313 auto callback = std::make_shared<MockIDMCallback>();
314 EXPECT_NE(callback, nullptr);
315 #ifdef PROXY_MOCK
316 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _)).Times(Exactly(2));
317 #else
318 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
319 #endif
320 auto testCallback = std::make_shared<TestIDMCallback>(callback);
321 AccountIAMClient::GetInstance().AddCredential(-1, testPara, testCallback);
322 #ifndef PROXY_MOCK
323 {
324 std::unique_lock<std::mutex> lock(testCallback->mutex);
325 testCallback->cv.wait_for(
__anon36e93b360502() 326 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
327 }
328 #endif
329 AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, nullptr);
330 testCallback->isReady = false;
331 AccountIAMClient::GetInstance().AddCredential(TEST_EXIST_ID, testPara, testCallback);
332 #ifndef PROXY_MOCK
333 {
334 std::unique_lock<std::mutex> lock(testCallback->mutex);
335 testCallback->cv.wait_for(
__anon36e93b360602() 336 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
337 }
338 #endif
339 }
340
341 /**
342 * @tc.name: AccountIAMClient_UpdateCredential_0100
343 * @tc.desc: Update credential.
344 * @tc.type: FUNC
345 * @tc.require: issueI5N90O
346 */
347 HWTEST_F(AccountIAMClientTest, AccountIAMClient_UpdateCredential_0100, TestSize.Level3)
348 {
349 CredentialParameters testPara = {};
350 auto callback = std::make_shared<MockIDMCallback>();
351 EXPECT_NE(callback, nullptr);
352 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
353 auto testCallback = std::make_shared<TestIDMCallback>(callback);
354 AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testCallback);
355 std::unique_lock<std::mutex> lock(testCallback->mutex);
356 testCallback->cv.wait_for(
__anon36e93b360702() 357 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
358 }
359
360 /**
361 * @tc.name: AccountIAMClient_UpdateCredential_200
362 * @tc.desc: Update credential.
363 * @tc.type: FUNC
364 * @tc.require: issueI5N90O
365 */
366 HWTEST_F(AccountIAMClientTest, AccountIAMClient_UpdateCredential_200, TestSize.Level3)
367 {
368 CredentialParameters testPara = {};
369 testPara.authType = AuthType::PIN;
370 auto callback = std::make_shared<MockIDMCallback>();
371 EXPECT_NE(callback, nullptr);
372 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
373 auto testCallback = std::make_shared<TestIDMCallback>(callback);
374 AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, nullptr);
375 AccountIAMClient::GetInstance().UpdateCredential(0, testPara, testCallback);
376 {
377 std::unique_lock<std::mutex> lock(testCallback->mutex);
378 testCallback->cv.wait_for(
__anon36e93b360802() 379 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
380 }
381 testCallback->isReady = false;
382 AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testCallback);
383 {
384 std::unique_lock<std::mutex> lock(testCallback->mutex);
385 testCallback->cv.wait_for(
__anon36e93b360902() 386 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
387 }
388 }
389
390 /**
391 * @tc.name: AccountIAMClient_Cancel_0100
392 * @tc.desc: Cancel.
393 * @tc.type: FUNC
394 * @tc.require: issueI5N90O
395 */
396 HWTEST_F(AccountIAMClientTest, AccountIAMClient_Cancel_0100, TestSize.Level3)
397 {
398 int32_t ret = AccountIAMClient::GetInstance().Cancel(TEST_USER_ID);
399 EXPECT_NE(ret, 0);
400 }
401
402 /**
403 * @tc.name: AccountIAMClient_DelCred_0100
404 * @tc.desc: Delete credential.
405 * @tc.type: FUNC
406 * @tc.require: issueI5N90O
407 */
408 HWTEST_F(AccountIAMClientTest, AccountIAMClient_DelCred_0100, TestSize.Level3)
409 {
410 uint64_t testCredentialId = 111;
411 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
412 auto callback = std::make_shared<MockIDMCallback>();
413 EXPECT_NE(callback, nullptr);
414 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
415 auto testCallback = std::make_shared<TestIDMCallback>(callback);
416 AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, nullptr);
417 AccountIAMClient::GetInstance().DelCred(0, testCredentialId, testAuthToken, testCallback);
418 {
419 std::unique_lock<std::mutex> lock(testCallback->mutex);
420 testCallback->cv.wait_for(
__anon36e93b360a02() 421 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
422 }
423 testCallback->isReady = false;
424 AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, testCallback);
425 {
426 std::unique_lock<std::mutex> lock(testCallback->mutex);
427 testCallback->cv.wait_for(
__anon36e93b360b02() 428 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
429 }
430 }
431
432 /**
433 * @tc.name: AccountIAMClient_GetCredentialInfo_0100
434 * @tc.desc: Get credential info.
435 * @tc.type: FUNC
436 * @tc.require: issueI5N90O
437 */
438 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetCredentialInfo_0100, TestSize.Level3)
439 {
440 auto callback = std::make_shared<MockGetCredInfoCallback>();
441 EXPECT_NE(callback, nullptr);
442 auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
443 EXPECT_CALL(*callback, OnCredentialInfo(_, _)).Times(Exactly(1));
444 AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, testCallback);
445 std::unique_lock<std::mutex> lock(testCallback->mutex);
446 testCallback->cv.wait_for(
__anon36e93b360c02() 447 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
448 }
449
450 /**
451 * @tc.name: AccountIAMClient_GetEnrolledId_0100
452 * @tc.desc: Get enrolled id.
453 * @tc.type: FUNC
454 * @tc.require:
455 */
456 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetEnrolledId_0100, TestSize.Level3)
457 {
458 auto callback = std::make_shared<MockGetEnrolledIdCallback>();
459 ASSERT_NE(callback, nullptr);
460 auto testCallback = std::make_shared<TestGetEnrolledIdCallback>(callback);
461 EXPECT_CALL(*callback, OnEnrolledId(_, _)).Times(Exactly(1));
462 AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testCallback);
463 std::unique_lock<std::mutex> lock(testCallback->mutex);
464 testCallback->cv.wait_for(
__anon36e93b360d02() 465 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
466 }
467
468 /**
469 * @tc.name: AccountIAMClient_GetAvailableStatus_0100
470 * @tc.desc: Get available status.
471 * @tc.type: FUNC
472 * @tc.require: issueI5N90O
473 */
474 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetAvailableStatus_0100, TestSize.Level3)
475 {
476 int32_t status;
477 AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
478 AccountIAMClient::AccountIAMDeathRecipient recipient;
479 recipient.OnRemoteDied(nullptr);
480 EXPECT_NE(status, 0);
481 }
482
483 /**
484 * @tc.name: AccountIAMClient_GetAvailableStatus_0200
485 * @tc.desc: Get available status.
486 * @tc.type: FUNC
487 * @tc.require: issueI5N90O
488 */
489 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetAvailableStatus_0200, TestSize.Level3)
490 {
491 int32_t status;
492 AuthTrustLevel level = static_cast<AuthTrustLevel>(0);
493 int32_t ret = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, level, status);
494 EXPECT_EQ(ERR_ACCOUNT_COMMON_INVALID_PARAMETER, ret);
495 }
496
497 /**
498 * @tc.name: AccountIAMClient_GetAvailableStatus_0300
499 * @tc.desc: AuthType is err.
500 * @tc.type: FUNC
501 * @tc.require: issueI5N90O
502 */
503 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetAvailableStatus_0300, TestSize.Level3)
504 {
505 int32_t status;
506 AuthTrustLevel level = static_cast<AuthTrustLevel>(20000);
507 AuthType authType = static_cast<AuthType>(-1);
508 int32_t ret = AccountIAMClient::GetInstance().GetAvailableStatus(authType, level, status);
509 EXPECT_EQ(ERR_ACCOUNT_COMMON_INVALID_PARAMETER, ret);
510 }
511
512 /**
513 * @tc.name: AccountIAMClient_GetProperty_0100
514 * @tc.desc: Get property.
515 * @tc.type: FUNC
516 * @tc.require: issueI5N90O
517 */
518 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetProperty_0100, TestSize.Level3)
519 {
520 GetPropertyRequest testRequest = {
521 .keys = { Attributes::AttributeKey::ATTR_PIN_SUB_TYPE }
522 };
523 auto callback = std::make_shared<MockGetSetPropCallback>();
524 EXPECT_NE(callback, nullptr);
525 auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
526 EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
527 AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequest, nullptr);
528 AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequest, testCallback);
529 std::unique_lock<std::mutex> lock(testCallback->mutex);
530 testCallback->cv.wait_for(
__anon36e93b360e02() 531 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
532 }
533
534 /**
535 * @tc.name: AccountIAMClient_GetPropertyById_0100
536 * @tc.desc: Get property by id.
537 * @tc.type: FUNC
538 * @tc.require:
539 */
540 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetPropertyById_0100, TestSize.Level3)
541 {
542 auto callback = std::make_shared<MockGetSetPropCallback>();
543 EXPECT_NE(callback, nullptr);
544 auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
545 EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
546 std::vector<Attributes::AttributeKey> keys { Attributes::AttributeKey::ATTR_PIN_SUB_TYPE };
547 AccountIAMClient::GetInstance().GetPropertyByCredentialId(
548 TEST_CREDENTIAL_ID, keys, nullptr);
549 AccountIAMClient::GetInstance().GetPropertyByCredentialId(
550 TEST_CREDENTIAL_ID, keys, testCallback);
551 std::unique_lock<std::mutex> lock(testCallback->mutex);
552 testCallback->cv.wait_for(
__anon36e93b360f02() 553 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
554 }
555
556 /**
557 * @tc.name: AccountIAMClient_SetProperty_0100
558 * @tc.desc: Set property.
559 * @tc.type: FUNC
560 * @tc.require: issueI5N90O
561 */
562 HWTEST_F(AccountIAMClientTest, AccountIAMClient_SetProperty_0100, TestSize.Level3)
563 {
564 SetPropertyRequest testRequest = {};
565 auto callback = std::make_shared<MockGetSetPropCallback>();
566 EXPECT_NE(callback, nullptr);
567 auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
568 EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
569 AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequest, nullptr);
570 AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequest, testCallback);
571 std::unique_lock<std::mutex> lock(testCallback->mutex);
572 testCallback->cv.wait_for(
__anon36e93b361002() 573 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
574 }
575
576 /**
577 * @tc.name: AccountIAMClient_AuthUser_0100
578 * @tc.desc: Auth user.
579 * @tc.type: FUNC
580 * @tc.require: issueI5N90O
581 */
582 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0100, TestSize.Level3)
583 {
584 SetPropertyRequest testRequest = {};
585 auto callback = std::make_shared<MockIDMCallback>();
586 EXPECT_NE(callback, nullptr);
587 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
588 auto testCallback = std::make_shared<TestIDMCallback>(callback);
589 AuthOptions authOptionsOne;
590 AccountIAMClient::GetInstance().AuthUser(
591 authOptionsOne, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
592 {
593 std::unique_lock<std::mutex> lock(testCallback->mutex);
594 testCallback->cv.wait_for(
__anon36e93b361102() 595 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
596 }
597 testCallback->isReady = false;
598 AuthOptions authOptionsTwo;
599 authOptionsTwo.accountId = TEST_USER_ID;
600 AccountIAMClient::GetInstance().AuthUser(
601 authOptionsTwo, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
602 {
603 std::unique_lock<std::mutex> lock(testCallback->mutex);
604 testCallback->cv.wait_for(
__anon36e93b361202() 605 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
606 }
607 }
608
609 /**
610 * @tc.name: AccountIAMClient_AuthUser_0200
611 * @tc.desc: Auth callback is nullptr.
612 * @tc.type: FUNC
613 * @tc.require: issueI5N90O
614 */
615 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0200, TestSize.Level3)
616 {
617 AuthOptions authOptions;
618 uint64_t ret = AccountIAMClient::GetInstance().AuthUser(
619 authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, nullptr);
620 EXPECT_EQ(ret, 0);
621 }
622
623 /**
624 * @tc.name: AccountIAMClient_Auth_0100
625 * @tc.desc: Auth current user.
626 * @tc.type: FUNC
627 * @tc.require: issueI5N90O
628 */
629 HWTEST_F(AccountIAMClientTest, AccountIAMClient_Auth_0100, TestSize.Level3)
630 {
631 SetPropertyRequest testRequest = {};
632 auto callback = std::make_shared<MockIDMCallback>();
633 EXPECT_NE(callback, nullptr);
634 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
635 auto testCallback = std::make_shared<TestIDMCallback>(callback);
636 AuthOptions authOptions;
637 AccountIAMClient::GetInstance().Auth(authOptions,
638 TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
639 std::unique_lock<std::mutex> lock(testCallback->mutex);
640 testCallback->cv.wait_for(
__anon36e93b361302() 641 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
642 }
643
644 /**
645 * @tc.name: AccountIAMClient_CancelAuth_0100
646 * @tc.desc: Cancel authentication.
647 * @tc.type: FUNC
648 * @tc.require: issueI5N90O
649 */
650 HWTEST_F(AccountIAMClientTest, AccountIAMClient_CancelAuth_0100, TestSize.Level3)
651 {
652 EXPECT_NE(ERR_OK, AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID));
653 }
654
655 #ifdef HAS_PIN_AUTH_PART
656 /**
657 * @tc.name: AccountIAMClient_RegisterPINInputer_0100
658 * @tc.desc: Register inputer.
659 * @tc.type: FUNC
660 * @tc.require: issueI5N90O
661 */
662 HWTEST_F(AccountIAMClientTest, AccountIAMClient_RegisterPINInputer_0100, TestSize.Level3)
663 {
664 std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
665 EXPECT_NE(nullptr, inputer);
666 AccountIAMClient::GetInstance().UnregisterPINInputer();
667 EXPECT_EQ(ERR_OK, AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
668 EXPECT_EQ(ERR_ACCOUNT_IAM_KIT_INPUTER_ALREADY_REGISTERED,
669 AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
670
671 AccountIAMClient::GetInstance().UnregisterPINInputer();
672 }
673
674 /**
675 * @tc.name: AccountIAMClient_RegisterInputer_0100
676 * @tc.desc: Unregister/Register inputer failed for unsupported auth type.
677 * @tc.type: FUNC
678 * @tc.require: issueI5N90O
679 */
680 HWTEST_F(AccountIAMClientTest, AccountIAMClient_RegisterInputer_0100, TestSize.Level3)
681 {
682 std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
683 EXPECT_NE(nullptr, inputer);
684 EXPECT_EQ(ERR_ACCOUNT_IAM_UNSUPPORTED_AUTH_TYPE,
685 AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputer));
686 EXPECT_EQ(ERR_ACCOUNT_IAM_UNSUPPORTED_AUTH_TYPE, AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN));
687 }
688 #endif
689
690 /**
691 * @tc.name: AccountIAMClient_SetAuthSubType_0100
692 * @tc.desc: SetAuthSubType.
693 * @tc.type: FUNC
694 * @tc.require: issueI5N90O
695 */
696 HWTEST_F(AccountIAMClientTest, AccountIAMClient_SetAuthSubType_0100, TestSize.Level3)
697 {
698 int32_t userId = 1111; // 1111: userId
699 int32_t type = 11;
700 EXPECT_EQ(0, AccountIAMClient::GetInstance().GetAuthSubType(userId));
701 AccountIAMClient::GetInstance().SetAuthSubType(userId, type);
702 EXPECT_EQ(type, AccountIAMClient::GetInstance().GetAuthSubType(userId));
703
704 AccountIAMClient::GetInstance().SetAuthSubType(userId, type + 1);
705 EXPECT_EQ(type, AccountIAMClient::GetInstance().GetAuthSubType(userId));
706 }
707
708 /**
709 * @tc.name: IDMCallbackStub_OnRemoteRequest_0100
710 * @tc.desc: OnRemoteRequest with wrong message code.
711 * @tc.type: FUNC
712 * @tc.require:
713 */
714 HWTEST_F(AccountIAMClientTest, IDMCallbackStub_OnRemoteRequest_0100, TestSize.Level3)
715 {
716 MessageParcel data;
717 MessageParcel reply;
718 MessageOption option = {MessageOption::TF_SYNC};
719 data.WriteInterfaceToken(IDMCallbackStub::GetDescriptor());
720
721 sptr<IDMCallbackStub> stub = new (std::nothrow) IDMCallbackService(TEST_USER_ID, nullptr);
722 ASSERT_NE(nullptr, stub);
723 int32_t ret = stub->OnRemoteRequest(INVALID_IPC_CODE, data, reply, option);
724 EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, ret);
725 }
726
727 /**
728 * @tc.name: IDMCallbackStub_ProcOnAcquireInfo_0100
729 * @tc.desc: ProcOnAcquireInfo.
730 * @tc.type: FUNC
731 * @tc.require:
732 */
733 HWTEST_F(AccountIAMClientTest, IDMCallbackStub_ProcOnAcquireInfo_0100, TestSize.Level3)
734 {
735 MessageParcel data;
736 MessageParcel reply;
737 MessageOption option = {MessageOption::TF_SYNC};
738
739 int32_t module = 0;
740 int32_t acquireInfo = 0;
741 std::vector<uint8_t> buffer;
742 data.WriteInterfaceToken(IDMCallbackStub::GetDescriptor());
743 data.WriteInt32(module);
744 data.WriteInt32(acquireInfo);
745 data.WriteUInt8Vector(buffer);
746
747 sptr<IDMCallbackStub> stub = new (std::nothrow) IDMCallbackService(TEST_USER_ID, nullptr);
748 ASSERT_NE(nullptr, stub);
749 int32_t ret =
750 stub->OnRemoteRequest(static_cast<uint32_t>(IIDMCallbackIpcCode::COMMAND_ON_ACQUIRE_INFO), data, reply, option);
751 EXPECT_EQ(ERR_OK, ret);
752 }
753
754 /**
755 * @tc.name: GetCredInfoCallbackStub_OnRemoteRequest_0100
756 * @tc.desc: OnRemoteRequest with wrong message code.
757 * @tc.type: FUNC
758 * @tc.require:
759 */
760 HWTEST_F(AccountIAMClientTest, GetCredInfoCallbackStub_OnRemoteRequest_0100, TestSize.Level3)
761 {
762 MessageParcel data;
763 MessageParcel reply;
764 MessageOption option = {MessageOption::TF_SYNC};
765 data.WriteInterfaceToken(GetCredInfoCallbackStub::GetDescriptor());
766
767 sptr<GetCredInfoCallbackStub> stub = new (std::nothrow) GetCredInfoCallbackService(nullptr);
768 ASSERT_NE(nullptr, stub);
769 int32_t ret = stub->OnRemoteRequest(INVALID_IPC_CODE, data, reply, option);
770 EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, ret);
771 }
772
773 /**
774 * @tc.name: GetCredInfoCallbackStub_ProcOnCredentialInfo_0100
775 * @tc.desc: ProcOnCredentialInfo.
776 * @tc.type: FUNC
777 * @tc.require:
778 */
779 HWTEST_F(AccountIAMClientTest, GetCredInfoCallbackStub_ProcOnCredentialInfo_0100, TestSize.Level3)
780 {
781 MessageParcel data;
782 MessageParcel reply;
783 MessageOption option = {MessageOption::TF_SYNC};
784
785 uint32_t vectorSize = 1;
786 CredentialInfo info;
787 std::vector<CredentialInfo> infoList = {info};
788 data.WriteInterfaceToken(GetCredInfoCallbackStub::GetDescriptor());
789 data.WriteUint32(vectorSize);
790 for (const auto &info : infoList) {
791 data.WriteUint64(info.credentialId);
792 data.WriteInt32(info.authType);
793 PinSubType pinType = info.pinType.value_or(PinSubType::PIN_MAX);
794 data.WriteInt32(pinType);
795 data.WriteUint64(info.templateId);
796 }
797
798 sptr<GetCredInfoCallbackStub> stub = new (std::nothrow) GetCredInfoCallbackService(nullptr);
799 ASSERT_NE(nullptr, stub);
800 int32_t ret = stub->OnRemoteRequest(static_cast<uint32_t>(IGetCredInfoCallbackIpcCode::COMMAND_ON_CREDENTIAL_INFO),
801 data, reply, option);
802 EXPECT_EQ(ERR_OK, ret);
803 }
804
805 /**
806 * @tc.name: GetSetPropCallbackStub_OnRemoteRequest_0100
807 * @tc.desc: OnRemoteRequest with wrong message code.
808 * @tc.type: FUNC
809 * @tc.require:
810 */
811 HWTEST_F(AccountIAMClientTest, GetSetPropCallbackStub_OnRemoteRequest_0100, TestSize.Level3)
812 {
813 MessageParcel data;
814 MessageParcel reply;
815 MessageOption option = {MessageOption::TF_SYNC};
816 data.WriteInterfaceToken(GetSetPropCallbackStub::GetDescriptor());
817
818 sptr<GetSetPropCallbackStub> stub = new (std::nothrow) GetSetPropCallbackService(nullptr);
819 ASSERT_NE(nullptr, stub);
820 int32_t ret = stub->OnRemoteRequest(INVALID_IPC_CODE, data, reply, option);
821 EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, ret);
822 }
823
824 /**
825 * @tc.name: AccountIAMClient001
826 * @tc.desc: Test the interface of the accountIAM calling the server not pass system applicaiton verify.
827 * @tc.type: FUNC
828 * @tc.require: issueI66BG5
829 */
830 HWTEST_F(AccountIAMClientTest, AccountIAMClient001, TestSize.Level3)
831 {
832 ASSERT_TRUE(MockTokenId("foundation"));
833 Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
834 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestNormalInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
835 ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
836 SetSelfTokenID(tokenIdEx.tokenIDEx);
837
838 int32_t status;
839 int result = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
840 ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, result);
841
842 ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID));
843
844 #ifdef HAS_PIN_AUTH_PART
845 std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
846 ASSERT_NE(nullptr, inputer);
847 ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
848
849 ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterPINInputer());
850
851 std::shared_ptr<IInputer> inputerTwo = std::make_shared<TestIInputer>();
852 ASSERT_NE(nullptr, inputerTwo);
853 ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR,
854 AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputerTwo));
855 ASSERT_EQ(
856 ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN));
857 #endif
858
859 std::vector<uint8_t> challenge;
860 ASSERT_EQ(AccountIAMClient::GetInstance().OpenSession(0, challenge), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
861
862 ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CloseSession(TEST_USER_ID));
863
864 ASSERT_EQ(AccountIAMClient::GetInstance().Cancel(TEST_USER_ID), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
865
866 auto callback = std::make_shared<MockGetCredInfoCallback>();
867 auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
868 ASSERT_NE(testCallback, nullptr);
869 EXPECT_CALL(*callback, OnCredentialInfo(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
870 ASSERT_EQ(AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, testCallback),
871 ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
872 std::unique_lock<std::mutex> lock(testCallback->mutex);
873 testCallback->cv.wait_for(
__anon36e93b361402() 874 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
875
876 auto getEnrolledIdCallback = std::make_shared<MockGetEnrolledIdCallback>();
877 auto testGetEnrolledIdCallback = std::make_shared<TestGetEnrolledIdCallback>(getEnrolledIdCallback);
878 ASSERT_NE(testGetEnrolledIdCallback, nullptr);
879 EXPECT_CALL(*getEnrolledIdCallback, OnEnrolledId(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
880 AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testGetEnrolledIdCallback);
881 std::unique_lock<std::mutex> cvLock(testGetEnrolledIdCallback->mutex);
882 testGetEnrolledIdCallback->cv.wait_for(cvLock, std::chrono::seconds(WAIT_TIME),
__anon36e93b361502() 883 [lockCallback = testGetEnrolledIdCallback]() { return lockCallback->isReady; });
884
885 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestNormalInfoParms.userID,
886 infoManagerTestNormalInfoParms.bundleName, infoManagerTestNormalInfoParms.instIndex);
887 AccessTokenKit::DeleteToken(tokenID);
888 SetSelfTokenID(g_selfTokenID);
889 }
890
891 /**
892 * @tc.name: AccountIAMClient002
893 * @tc.desc: Test accountIAM interface call server which result returned by the callback not pass system app verify.
894 * @tc.type: FUNC
895 * @tc.require: issueI66BG5
896 */
897 HWTEST_F(AccountIAMClientTest, AccountIAMClient002, TestSize.Level3)
898 {
899 ASSERT_TRUE(MockTokenId("foundation"));
900 Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
901 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestNormalInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
902 ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
903 SetSelfTokenID(tokenIdEx.tokenIDEx);
904
905 GetPropertyRequest testRequestGet = {};
906 auto callback = std::make_shared<MockGetSetPropCallback>();
907 EXPECT_NE(callback, nullptr);
908 auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
909 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
910 AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequestGet, testCallback);
911 Wait(testCallback);
912
913 SetPropertyRequest testRequestSet = {};
914 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
915 testCallback->isReady = false;
916 AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequestSet, testCallback);
917 Wait(testCallback);
918
919 CredentialParameters testPara = {};
920 auto idmCallback = std::make_shared<MockIDMCallback>();
921 ASSERT_NE(idmCallback, nullptr);
922 auto testIDMCallback = std::make_shared<TestIDMCallback>(idmCallback);
923 EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
924 AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, testIDMCallback);
925 Wait(testIDMCallback);
926
927 EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
928 testIDMCallback->isReady = false;
929 AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testIDMCallback);
930 Wait(testIDMCallback);
931
932 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
933 uint64_t testCredentialId = 111;
934 EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
935 testIDMCallback->isReady = false;
936 AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, testIDMCallback);
937 Wait(testIDMCallback);
938
939 EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
940 testIDMCallback->isReady = false;
941 AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, testIDMCallback);
942 Wait(testIDMCallback);
943
944 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestNormalInfoParms.userID,
945 infoManagerTestNormalInfoParms.bundleName, infoManagerTestNormalInfoParms.instIndex);
946 AccessTokenKit::DeleteToken(tokenID);
947 SetSelfTokenID(g_selfTokenID);
948 }
949
950 /**
951 * @tc.name: AccountIAMClient003
952 * @tc.desc: Test the interface of the accountIAM calling the server pass system applicaiton verify.
953 * @tc.type: FUNC
954 * @tc.require: issueI66BG5
955 */
956 HWTEST_F(AccountIAMClientTest, AccountIAMClient003, TestSize.Level3)
957 {
958 ASSERT_TRUE(MockTokenId("foundation"));
959 Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
960 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestSystemInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
961 ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
962 SetSelfTokenID(tokenIdEx.tokenIDEx);
963
964 int32_t status;
965 int result = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
966 ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, result);
967
968 ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID));
969
970 #ifdef HAS_PIN_AUTH_PART
971 std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
972 ASSERT_NE(nullptr, inputer);
973 ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
974
975 ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterPINInputer());
976
977 std::shared_ptr<IInputer> inputerTwo = std::make_shared<TestIInputer>();
978 ASSERT_NE(nullptr, inputerTwo);
979 ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR,
980 AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputerTwo));
981 ASSERT_NE(
982 ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN));
983 #endif
984
985 std::vector<uint8_t> challenge;
986 ASSERT_NE(AccountIAMClient::GetInstance().OpenSession(0, challenge), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
987
988 ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CloseSession(TEST_USER_ID));
989
990 ASSERT_NE(AccountIAMClient::GetInstance().Cancel(TEST_USER_ID), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
991
992 auto callback = std::make_shared<MockGetCredInfoCallback>();
993 auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
994 ASSERT_NE(testCallback, nullptr);
995 ASSERT_NE(AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, testCallback),
996 ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
997
998 auto getEnrolledIdCallback = std::make_shared<MockGetEnrolledIdCallback>();
999 auto testGetEnrolledIdCallback = std::make_shared<TestGetEnrolledIdCallback>(getEnrolledIdCallback);
1000 ASSERT_NE(testGetEnrolledIdCallback, nullptr);
1001 EXPECT_CALL(*getEnrolledIdCallback, OnEnrolledId(ERR_ACCOUNT_COMMON_PERMISSION_DENIED, _)).Times(1);
1002 AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testGetEnrolledIdCallback);
1003 std::unique_lock<std::mutex> lock(testGetEnrolledIdCallback->mutex);
1004 testGetEnrolledIdCallback->cv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
__anon36e93b361602() 1005 [lockCallback = testGetEnrolledIdCallback]() { return lockCallback->isReady; });
1006
1007 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestSystemInfoParms.userID,
1008 infoManagerTestSystemInfoParms.bundleName, infoManagerTestSystemInfoParms.instIndex);
1009 AccessTokenKit::DeleteToken(tokenID);
1010 SetSelfTokenID(g_selfTokenID);
1011 }
1012
1013 /**
1014 * @tc.name: AccountIAMClient004
1015 * @tc.desc: Test accountIAM interface call server which result returned by the callback pass system app verify.
1016 * @tc.type: FUNC
1017 * @tc.require: issueI66BG5
1018 */
1019 HWTEST_F(AccountIAMClientTest, AccountIAMClient004, TestSize.Level3)
1020 {
1021 ASSERT_TRUE(MockTokenId("foundation"));
1022 Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
1023 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestSystemInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
1024 ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
1025 SetSelfTokenID(tokenIdEx.tokenIDEx);
1026
1027 GetPropertyRequest testRequestGet = {};
1028 auto testCallback = std::make_shared<CheckResultGetSetPropCallback>();
1029 ASSERT_NE(testCallback, nullptr);
1030 AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequestGet, testCallback);
1031 ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1032
1033 SetPropertyRequest testRequestSet = {};
1034 AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequestSet, testCallback);
1035 ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1036
1037 CredentialParameters testPara = {};
1038 auto testIDMCallback = std::make_shared<CheckResultIDMCallback>();
1039 ASSERT_NE(testIDMCallback, nullptr);
1040 AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, testIDMCallback);
1041 ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1042
1043 AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testIDMCallback);
1044 ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1045
1046 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
1047 uint64_t testCredentialId = 111;
1048 AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, testIDMCallback);
1049 ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1050
1051 AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, testIDMCallback);
1052 ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1053
1054 auto testGetEnrolledIdCallback = std::make_shared<TestOnEnrolledIdCallback>();
1055 ASSERT_NE(testGetEnrolledIdCallback, nullptr);
1056 AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testGetEnrolledIdCallback);
1057 ASSERT_EQ(testGetEnrolledIdCallback->GetResult(), ERR_OK);
1058
1059 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestSystemInfoParms.userID,
1060 infoManagerTestSystemInfoParms.bundleName, infoManagerTestSystemInfoParms.instIndex);
1061 AccessTokenKit::DeleteToken(tokenID);
1062 SetSelfTokenID(g_selfTokenID);
1063 }
1064
1065 #ifdef SUPPORT_DOMAIN_ACCOUNTS
1066 #ifdef HAS_PIN_AUTH_PART
1067 /**
1068 * @tc.name: StartDomainAuth001
1069 * @tc.desc: test StartDomainAuth.
1070 * @tc.type: FUNC
1071 * @tc.require:
1072 */
1073 HWTEST_F(AccountIAMClientTest, StartDomainAuth001, TestSize.Level3)
1074 {
1075 auto callback = std::make_shared<MockIDMCallback>();
1076 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_IAM_KIT_INPUTER_NOT_REGISTERED, _)).Times(Exactly(1));
1077 auto testCallback = std::make_shared<TestIDMCallback>(callback);
1078 AccountIAMClient::GetInstance().domainInputer_ = nullptr;
1079 uint64_t ret = AccountIAMClient::GetInstance().StartDomainAuth(TEST_USER_ID, testCallback);
1080 std::unique_lock<std::mutex> lock(testCallback->mutex);
1081 testCallback->cv.wait_for(
__anon36e93b361702() 1082 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1083 EXPECT_EQ(0, ret);
1084 }
1085
1086 /**
1087 * @tc.name: StartDomainAuth002
1088 * @tc.desc: test StartDomainAuth.
1089 * @tc.type: FUNC
1090 * @tc.require:
1091 */
1092 HWTEST_F(AccountIAMClientTest, StartDomainAuth002, TestSize.Level3)
1093 {
1094 auto callback = std::make_shared<MockIDMCallback>();
1095 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR, _)).Times(Exactly(1));
1096 auto testCallback = std::make_shared<TestIDMCallback>(callback);
1097 std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
1098 AccountIAMClient::GetInstance().domainInputer_ = inputer;
1099 uint64_t ret = AccountIAMClient::GetInstance().StartDomainAuth(TEST_USER_ID, testCallback);
1100 std::unique_lock<std::mutex> lock(testCallback->mutex);
1101 testCallback->cv.wait_for(
__anon36e93b361802() 1102 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1103 EXPECT_EQ(0, ret);
1104 testing::Mock::AllowLeak(testCallback.get());
1105 }
1106 #endif
1107 #endif // SUPPORT_DOMAIN_ACCOUNTS
1108
1109 /**
1110 * @tc.name: PrepareRemoteAuthTest001
1111 * @tc.desc: test PrepareRemoteAuth.
1112 * @tc.type: FUNC
1113 * @tc.require:
1114 */
1115 HWTEST_F(AccountIAMClientTest, PrepareRemoteAuthTest001, TestSize.Level3)
1116 {
1117 int32_t ret = AccountIAMClient::GetInstance().PrepareRemoteAuth("testString", nullptr);
1118 EXPECT_EQ(ret, ERR_ACCOUNT_COMMON_NULL_PTR_ERROR);
1119 }
1120
1121 /**
1122 * @tc.name: AccountIAMClient_AuthUser_0300
1123 * @tc.desc: Auth user.
1124 * @tc.type: FUNC
1125 * @tc.require:
1126 */
1127 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0300, TestSize.Level3)
1128 {
1129 auto callback = std::make_shared<MockIDMCallback>();
1130 EXPECT_NE(callback, nullptr);
1131 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
1132 auto testCallback = std::make_shared<TestIDMCallback>(callback);
1133 AuthOptions authOptions;
1134
1135 authOptions.hasRemoteAuthOptions = true;
1136
1137 AccountIAMClient::GetInstance().AuthUser(
1138 authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
1139 {
1140 std::unique_lock<std::mutex> lock(testCallback->mutex);
1141 testCallback->cv.wait_for(
__anon36e93b361902() 1142 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1143 }
1144 }
1145
1146 /**
1147 * @tc.name: AccountIAMClient_AuthUser_0400
1148 * @tc.desc: Auth user.
1149 * @tc.type: FUNC
1150 * @tc.require:
1151 */
1152 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0400, TestSize.Level3)
1153 {
1154 auto callback = std::make_shared<MockIDMCallback>();
1155 EXPECT_NE(callback, nullptr);
1156 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
1157 auto testCallback = std::make_shared<TestIDMCallback>(callback);
1158 AuthOptions authOptions;
1159
1160 authOptions.hasRemoteAuthOptions = true;
1161 authOptions.remoteAuthOptions.hasVerifierNetworkId = true;
1162 authOptions.remoteAuthOptions.verifierNetworkId = "testVerifierNetworkId";
1163 authOptions.remoteAuthOptions.hasCollectorNetworkId = true;
1164 authOptions.remoteAuthOptions.collectorNetworkId = "testCollectorNetworkId";
1165 authOptions.remoteAuthOptions.hasCollectorTokenId = true;
1166 authOptions.remoteAuthOptions.collectorTokenId = 0;
1167
1168 AccountIAMClient::GetInstance().AuthUser(
1169 authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
1170 {
1171 std::unique_lock<std::mutex> lock(testCallback->mutex);
1172 testCallback->cv.wait_for(
__anon36e93b361a02() 1173 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1174 }
1175 }
1176
1177 /**
1178 * @tc.name: ResetAccountIAMProxy001
1179 * @tc.desc: test ResetAccountIAMProxy.
1180 * @tc.type: FUNC
1181 * @tc.require:
1182 */
1183 HWTEST_F(AccountIAMClientTest, ResetAccountIAMProxy001, TestSize.Level3)
1184 {
1185 wptr<IRemoteObject> remote;
1186 sptr<IAccountIAM> proxy = AccountIAMClient::GetInstance().proxy_;
1187 AccountIAMClient::GetInstance().proxy_ = nullptr;
1188 AccountIAMClient::GetInstance().ResetAccountIAMProxy(remote);
1189 sptr<IAccountIAM> testIAccountIAM = new (std::nothrow) AccountIAMProxy(nullptr);
1190 AccountIAMClient::GetInstance().proxy_ = testIAccountIAM;
1191 EXPECT_NE(AccountIAMClient::GetInstance().proxy_, nullptr);
1192 AccountIAMClient::GetInstance().ResetAccountIAMProxy(remote);
1193 AccountIAMClient::GetInstance().proxy_ = proxy;
1194 }
1195
1196 /**
1197 * @tc.name: AccountIAMClient_DelUser_0100
1198 * @tc.desc: Delete user.
1199 * @tc.type: FUNC
1200 * @tc.require: issueI5N90O
1201 */
1202 HWTEST_F(AccountIAMClientTest, AccountIAMClient_DelUser_0100, TestSize.Level3)
1203 {
1204 AccountIAMClient::GetInstance().UnregisterPINInputer();
1205 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
1206 auto callback = std::make_shared<MockIDMCallback>();
1207 EXPECT_NE(callback, nullptr);
1208 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
1209 auto testCallback = std::make_shared<TestIDMCallback>(callback);
1210 AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, nullptr);
1211 AccountIAMClient::GetInstance().DelUser(0, testAuthToken, testCallback);
1212 {
1213 std::unique_lock<std::mutex> lock(testCallback->mutex);
1214 testCallback->cv.wait_for(
__anon36e93b361b02() 1215 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1216 }
1217 testCallback->isReady = false;
1218 AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, testCallback);
1219 {
1220 std::unique_lock<std::mutex> lock(testCallback->mutex);
1221 testCallback->cv.wait_for(
__anon36e93b361c02() 1222 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1223 }
1224 AccountIAMClient::GetInstance().UnregisterPINInputer();
1225 }
1226 } // namespace AccountTest
1227 } // namespace OHOS