1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "user_idm_callback_service_test.h"
17
18 #include "user_idm_callback_service.h"
19 #include "iam_ptr.h"
20 #include "mock_user_idm_client_callback.h"
21
22 namespace OHOS {
23 namespace UserIam {
24 namespace UserAuth {
25 using namespace testing;
26 using namespace testing::ext;
27
SetUpTestCase()28 void UserIdmCallbackServiceTest::SetUpTestCase()
29 {
30 }
31
TearDownTestCase()32 void UserIdmCallbackServiceTest::TearDownTestCase()
33 {
34 }
35
SetUp()36 void UserIdmCallbackServiceTest::SetUp()
37 {
38 }
39
TearDown()40 void UserIdmCallbackServiceTest::TearDown()
41 {
42 }
43
44 HWTEST_F(UserIdmCallbackServiceTest, UserIdmCallbackServiceTest001, TestSize.Level0)
45 {
46 int32_t testResult = FAIL;
47 Attributes testExtraInfo;
48
49 int32_t testModule = 52334;
50 int32_t testAcquireInfo = 57845;
51
52 std::shared_ptr<UserIdmClientCallback> idmClientCallback = nullptr;
53 auto service = Common::MakeShared<IdmCallbackService>(idmClientCallback);
54 EXPECT_NE(service, nullptr);
55 service->OnResult(testResult, testExtraInfo);
56 service->OnAcquireInfo(testModule, testAcquireInfo, testExtraInfo);
57 }
58
59 HWTEST_F(UserIdmCallbackServiceTest, UserIdmCallbackServiceTest002, TestSize.Level0)
60 {
61 int32_t testResult = FAIL;
62 Attributes testExtraInfo;
63
64 int32_t testModule = 52334;
65 int32_t testAcquireInfo = 57845;
66
67 auto idmClientCallback = Common::MakeShared<MockUserIdmClientCallback>();
68 EXPECT_NE(idmClientCallback, nullptr);
69 EXPECT_CALL(*idmClientCallback, OnResult(_, _)).Times(1);
70 ON_CALL(*idmClientCallback, OnResult)
71 .WillByDefault(
__anon119b27390102(int32_t result, const Attributes &extraInfo) 72 [&testResult](int32_t result, const Attributes &extraInfo) {
73 EXPECT_EQ(result, testResult);
74 }
75 );
76 EXPECT_CALL(*idmClientCallback, OnAcquireInfo(_, _, _)).Times(1);
77 ON_CALL(*idmClientCallback, OnAcquireInfo)
78 .WillByDefault(
__anon119b27390202(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) 79 [&testModule, &testAcquireInfo](int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) {
80 EXPECT_EQ(module, testModule);
81 EXPECT_EQ(acquireInfo, testAcquireInfo);
82 }
83 );
84 auto service = Common::MakeShared<IdmCallbackService>(idmClientCallback);
85 EXPECT_NE(service, nullptr);
86 service->OnResult(testResult, testExtraInfo);
87 service->OnAcquireInfo(testModule, testAcquireInfo, testExtraInfo);
88 }
89
90 HWTEST_F(UserIdmCallbackServiceTest, IdmGetCredInfoCallbackServiceTest001, TestSize.Level0)
91 {
92 std::vector<CredentialInfo> credInfoList;
93
94 std::shared_ptr<GetCredentialInfoCallback> getCredInfoCallback = nullptr;
95 auto service = Common::MakeShared<IdmGetCredInfoCallbackService>(getCredInfoCallback);
96 EXPECT_NE(service, nullptr);
97 service->OnCredentialInfos(credInfoList);
98 }
99
100 HWTEST_F(UserIdmCallbackServiceTest, IdmGetCredInfoCallbackServiceTest002, TestSize.Level0)
101 {
102 CredentialInfo info1 = {PIN, PIN_SIX, 10, 20};
103 CredentialInfo info2 = {FACE, std::nullopt, 100, 200};
104 CredentialInfo info3 = {FINGERPRINT, std::nullopt, 1000, 2000};
105 std::vector<CredentialInfo> credInfoList = {info1, info2, info3};
106
107 auto getCredInfoCallback = Common::MakeShared<MockGetCredentialInfoCallback>();
108 EXPECT_NE(getCredInfoCallback, nullptr);
109 EXPECT_CALL(*getCredInfoCallback, OnCredentialInfo(_))
110 .WillOnce(
__anon119b27390302(const std::vector<CredentialInfo> &infoList) 111 [](const std::vector<CredentialInfo> &infoList) {
112 EXPECT_EQ(infoList.size(), 3);
113 EXPECT_EQ(infoList[0].authType, PIN);
114 EXPECT_EQ(infoList[1].authType, FACE);
115 EXPECT_EQ(infoList[2].authType, FINGERPRINT);
116 }
117 );
118
119 auto service = Common::MakeShared<IdmGetCredInfoCallbackService>(getCredInfoCallback);
120 EXPECT_NE(service, nullptr);
121 service->OnCredentialInfos(credInfoList);
122 }
123
124 HWTEST_F(UserIdmCallbackServiceTest, IdmGetSecureUserInfoCallbackServiceTest001, TestSize.Level0)
125 {
126 SecUserInfo secUserInfo = {};
127
128 std::shared_ptr<GetSecUserInfoCallback> getSecInfoCallback = nullptr;
129 auto service = Common::MakeShared<IdmGetSecureUserInfoCallbackService>(getSecInfoCallback);
130 EXPECT_NE(service, nullptr);
131 service->OnSecureUserInfo(secUserInfo);
132 }
133
134 HWTEST_F(UserIdmCallbackServiceTest, IdmGetSecureUserInfoCallbackServiceTest002, TestSize.Level0)
135 {
136 auto getSecInfoCallback = Common::MakeShared<MockGetSecUserInfoCallback>();
137 EXPECT_NE(getSecInfoCallback, nullptr);
138 EXPECT_CALL(*getSecInfoCallback, OnSecUserInfo(_))
139 .WillOnce(
__anon119b27390402(const SecUserInfo &info) 140 [](const SecUserInfo &info) {
141 EXPECT_EQ(info.secureUid, 1000);
142 EXPECT_EQ(info.enrolledInfo.size(), 2);
143 EXPECT_EQ(info.enrolledInfo[0].authType, FACE);
144 EXPECT_EQ(info.enrolledInfo[0].enrolledId, 10);
145 EXPECT_EQ(info.enrolledInfo[1].authType, FINGERPRINT);
146 EXPECT_EQ(info.enrolledInfo[1].enrolledId, 20);
147 }
148 );
149
150 auto service = Common::MakeShared<IdmGetSecureUserInfoCallbackService>(getSecInfoCallback);
151 EXPECT_NE(service, nullptr);
152
153 SecUserInfo secUserInfo = {};
154 secUserInfo.secureUid = 1000;
155 secUserInfo.enrolledInfo = {{FACE, 10}, {FINGERPRINT, 20}};
156 service->OnSecureUserInfo(secUserInfo);
157 }
158 } // namespace UserAuth
159 } // namespace UserIam
160 } // namespace OHOS