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