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 "user_auth_proxy_test.h"
17
18 #include "iam_ptr.h"
19 #include "user_auth_proxy.h"
20 #include "mock_modal_callback.h"
21 #include "mock_remote_object.h"
22 #include "mock_user_auth_service.h"
23 #include "mock_user_access_ctrl_callback_service.h"
24 #include "mock_user_access_ctrl_client_callback.h"
25 #include "mock_user_auth_client_callback.h"
26 #include "mock_user_auth_callback_service.h"
27 #include "mock_iuser_auth_widget_callback.h"
28 #include "modal_callback_service.h"
29 #include "user_auth_callback_service.h"
30 #include "user_access_ctrl_callback_service.h"
31 #include "widget_callback_service.h"
32
33 namespace OHOS {
34 namespace UserIam {
35 namespace UserAuth {
36 using namespace testing;
37 using namespace testing::ext;
38
SetUpTestCase()39 void UserAuthProxyTest::SetUpTestCase()
40 {
41 }
42
TearDownTestCase()43 void UserAuthProxyTest::TearDownTestCase()
44 {
45 }
46
SetUp()47 void UserAuthProxyTest::SetUp()
48 {
49 }
50
TearDown()51 void UserAuthProxyTest::TearDown()
52 {
53 }
54
55 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetEnrolledState001, TestSize.Level0)
56 {
57 int32_t testApiVersion = 0;
58 AuthType testAuthType = FACE;
59 uint16_t credentialDigest = 23962;
60 uint16_t credentialCount = 1;
61 EnrolledState enrolledState;
62 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
63 EXPECT_NE(obj, nullptr);
64 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
65 EXPECT_NE(proxy, nullptr);
66 auto service = Common::MakeShared<MockUserAuthService>();
67 EXPECT_NE(service, nullptr);
68 EXPECT_CALL(*service, GetEnrolledState(_, _, _))
69 .Times(Exactly(1))
70 .WillOnce([testApiVersion, testAuthType, credentialDigest, credentialCount](int32_t apiVersion,
__anonec45643e0102(int32_t apiVersion, AuthType authType, EnrolledState &enrolledState) 71 AuthType authType, EnrolledState &enrolledState) {
72 EXPECT_EQ(testApiVersion, apiVersion);
73 EXPECT_EQ(testAuthType, authType);
74 enrolledState.credentialDigest = credentialDigest;
75 enrolledState.credentialCount = credentialCount;
76 return SUCCESS;
77 });
78 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
79 ON_CALL(*obj, SendRequest)
__anonec45643e0202(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 80 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
81 service->OnRemoteRequest(code, data, reply, option);
82 return SUCCESS;
83 });
84 EXPECT_EQ(proxy->GetEnrolledState(testApiVersion, testAuthType, enrolledState), SUCCESS);
85 EXPECT_EQ(credentialDigest, enrolledState.credentialDigest);
86 EXPECT_EQ(credentialCount, enrolledState.credentialCount);
87 }
88
89 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetEnrolledState002, TestSize.Level0)
90 {
91 int32_t testApiVersion = 0;
92 AuthType testAuthType = FACE;
93 uint16_t credentialDigest = 23962;
94 uint16_t credentialCount = 1;
95 EnrolledState enrolledState;
96 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
97 EXPECT_NE(obj, nullptr);
98 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
99 EXPECT_NE(proxy, nullptr);
100 auto service = Common::MakeShared<MockUserAuthService>();
101 EXPECT_NE(service, nullptr);
102 EXPECT_CALL(*service, GetEnrolledState(_, _, _))
103 .Times(Exactly(1))
104 .WillOnce([testApiVersion, testAuthType, credentialDigest, credentialCount](int32_t apiVersion,
__anonec45643e0302(int32_t apiVersion, AuthType authType, EnrolledState &enrolledState) 105 AuthType authType, EnrolledState &enrolledState) {
106 EXPECT_EQ(testApiVersion, apiVersion);
107 EXPECT_EQ(testAuthType, authType);
108 enrolledState.credentialDigest = credentialDigest;
109 enrolledState.credentialCount = credentialCount;
110 return SUCCESS;
111 });
112 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
113 ON_CALL(*obj, SendRequest)
__anonec45643e0402(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 114 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
115 service->OnRemoteRequest(code, data, reply, option);
116 reply.WriteInt32(GENERAL_ERROR);
117 return SUCCESS;
118 });
119 EXPECT_EQ(proxy->GetEnrolledState(testApiVersion, testAuthType, enrolledState), SUCCESS);
120 EXPECT_EQ(credentialDigest, enrolledState.credentialDigest);
121 EXPECT_EQ(credentialCount, enrolledState.credentialCount);
122 }
123
124 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetAvailableStatus, TestSize.Level0)
125 {
126 static const int32_t testApiVersion = 0;
127 static const AuthType testAuthType = FACE;
128 static const AuthTrustLevel testAuthTrustLevel = ATL3;
129 static const int32_t testUserId = 100;
130 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
131 EXPECT_NE(obj, nullptr);
132 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
133 EXPECT_NE(proxy, nullptr);
134 auto service = Common::MakeShared<MockUserAuthService>();
135 EXPECT_NE(service, nullptr);
136 EXPECT_CALL(*service, GetAvailableStatus(_, _, _, _))
137 .Times(Exactly(1))
__anonec45643e0502(int32_t apiVersion, int32_t userId, AuthType authType, AuthTrustLevel authTrustLevel) 138 .WillOnce([](int32_t apiVersion, int32_t userId, AuthType authType, AuthTrustLevel authTrustLevel) {
139 return SUCCESS;
140 });
141 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(2);
142 ON_CALL(*obj, SendRequest)
__anonec45643e0602(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 143 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
144 service->OnRemoteRequest(code, data, reply, option);
145 return SUCCESS;
146 });
147 EXPECT_EQ(proxy->GetAvailableStatus(testApiVersion, testUserId, testAuthType, testAuthTrustLevel), SUCCESS);
148 EXPECT_EQ(proxy->GetAvailableStatus(testApiVersion, testAuthType, testAuthTrustLevel), SUCCESS);
149 }
150
151 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetProperty001, TestSize.Level0)
152 {
153 static const int32_t testUserId = 200;
154 static const AuthType testAuthType = FACE;
155 std::vector<Attributes::AttributeKey> testKeys = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
156 Attributes::ATTR_SCHEDULE_MODE};
157
158 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
159 EXPECT_NE(obj, nullptr);
160 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
161 EXPECT_NE(proxy, nullptr);
162 auto getPropCallback = Common::MakeShared<MockGetPropCallback>();
163 EXPECT_NE(getPropCallback, nullptr);
164 sptr<GetExecutorPropertyCallbackInterface> testCallback(
165 new (std::nothrow) GetExecutorPropertyCallbackService(getPropCallback));
166 auto service = Common::MakeShared<MockUserAuthService>();
167 EXPECT_NE(service, nullptr);
168 EXPECT_CALL(*service, GetProperty(_, _, _, _))
169 .Times(Exactly(1))
170 .WillOnce([&testCallback](std::optional<int32_t> userId, AuthType authType,
__anonec45643e0702(std::optional<int32_t> userId, AuthType authType, const std::vector<Attributes::AttributeKey> &keys, sptr<GetExecutorPropertyCallbackInterface> &callback) 171 const std::vector<Attributes::AttributeKey> &keys, sptr<GetExecutorPropertyCallbackInterface> &callback) {
172 EXPECT_TRUE(userId.has_value());
173 EXPECT_EQ(userId.value(), testUserId);
174 EXPECT_EQ(authType, testAuthType);
175 EXPECT_THAT(keys, ElementsAre(Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
176 Attributes::ATTR_SCHEDULE_MODE));
177 EXPECT_EQ(callback, testCallback);
178 });
179 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
180 ON_CALL(*obj, SendRequest)
__anonec45643e0802(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 181 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
182 service->OnRemoteRequest(code, data, reply, option);
183 return SUCCESS;
184 });
185 proxy->GetProperty(testUserId, testAuthType, testKeys, testCallback);
186 }
187
188 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetProperty002, TestSize.Level0)
189 {
190 static const int32_t testUserId = 200;
191 static const AuthType testAuthType = FACE;
192 std::vector<Attributes::AttributeKey> testKeys = {};
193
194 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
195 EXPECT_NE(obj, nullptr);
196 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
197 EXPECT_NE(proxy, nullptr);
198 sptr<GetExecutorPropertyCallbackInterface> testCallback(nullptr);
199 proxy->GetProperty(testUserId, testAuthType, testKeys, testCallback);
200 }
201
202 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetProperty003, TestSize.Level0)
203 {
204 static const int32_t testUserId = 200;
205 static const AuthType testAuthType = FACE;
206 std::vector<Attributes::AttributeKey> testKeys = {};
207
208 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
209 EXPECT_NE(obj, nullptr);
210 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
211 EXPECT_NE(proxy, nullptr);
212 auto getPropCallback = Common::MakeShared<MockGetPropCallback>();
213 EXPECT_NE(getPropCallback, nullptr);
214 sptr<GetExecutorPropertyCallbackInterface> testCallback(
215 new (std::nothrow) GetExecutorPropertyCallbackService(getPropCallback));
216 proxy->GetProperty(testUserId, testAuthType, testKeys, testCallback);
217 }
218
219 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetProperty004, TestSize.Level0)
220 {
221 static const int32_t testUserId = 200;
222 static const AuthType testAuthType = FACE;
223 std::vector<Attributes::AttributeKey> testKeys = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
224 Attributes::ATTR_SCHEDULE_MODE};
225 testKeys.resize(513);
226
227 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
228 EXPECT_NE(obj, nullptr);
229 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
230 EXPECT_NE(proxy, nullptr);
231 auto getPropCallback = Common::MakeShared<MockGetPropCallback>();
232 EXPECT_NE(getPropCallback, nullptr);
233 sptr<GetExecutorPropertyCallbackInterface> testCallback(
234 new (std::nothrow) GetExecutorPropertyCallbackService(getPropCallback));
235 proxy->GetProperty(testUserId, testAuthType, testKeys, testCallback);
236 }
237
238 HWTEST_F(UserAuthProxyTest, UserAuthProxySetProperty001, TestSize.Level0)
239 {
240 static const AuthType testAuthType = FACE;
241
242 Attributes testAttr;
243 EXPECT_EQ(testAttr.SetInt32Value(Attributes::ATTR_RESULT_CODE, 1), true);
244
245 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
246 EXPECT_NE(obj, nullptr);
247 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
248 EXPECT_NE(proxy, nullptr);
249 auto setPropCallback = Common::MakeShared<MockSetPropCallback>();
250 EXPECT_NE(setPropCallback, nullptr);
251 sptr<SetExecutorPropertyCallbackInterface> testCallback(
252 new (std::nothrow) SetExecutorPropertyCallbackService(setPropCallback));
253 auto service = Common::MakeShared<MockUserAuthService>();
254 EXPECT_NE(service, nullptr);
255 EXPECT_CALL(*service, SetProperty(_, _, _, _))
256 .Times(Exactly(1))
257 .WillOnce([&testCallback](int32_t userId, AuthType authType,
__anonec45643e0902(int32_t userId, AuthType authType, const Attributes &attributes, sptr<SetExecutorPropertyCallbackInterface> &callback) 258 const Attributes &attributes, sptr<SetExecutorPropertyCallbackInterface> &callback) {
259 EXPECT_EQ(userId, 0);
260 EXPECT_EQ(authType, testAuthType);
261 int32_t resultCode;
262 EXPECT_EQ(attributes.GetInt32Value(Attributes::ATTR_RESULT_CODE, resultCode), true);
263 EXPECT_EQ(resultCode, 1);
264 EXPECT_EQ(callback, testCallback);
265 });
266 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
267 ON_CALL(*obj, SendRequest)
__anonec45643e0a02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 268 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
269 service->OnRemoteRequest(code, data, reply, option);
270 return SUCCESS;
271 });
272 proxy->SetProperty(0, testAuthType, testAttr, testCallback);
273 }
274
275 HWTEST_F(UserAuthProxyTest, UserAuthProxySetProperty002, TestSize.Level0)
276 {
277 static const AuthType testAuthType = FACE;
278
279 Attributes testAttr;
280 EXPECT_EQ(testAttr.SetInt32Value(Attributes::ATTR_RESULT_CODE, 1), true);
281
282 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
283 EXPECT_NE(obj, nullptr);
284 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
285 EXPECT_NE(proxy, nullptr);
286 sptr<SetExecutorPropertyCallbackInterface> testCallback(nullptr);
287 proxy->SetProperty(0, testAuthType, testAttr, testCallback);
288 }
289
290 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuth001, TestSize.Level0)
291 {
292 static const int32_t testApiVersion = 0;
293 static const AuthType testAuthType = FACE;
294 static const AuthTrustLevel testAtl = ATL1;
295 const std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
296
297 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
298 EXPECT_NE(obj, nullptr);
299 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
300 EXPECT_NE(proxy, nullptr);
301 auto authCallback = Common::MakeShared<MockAuthenticationCallback>();
302 EXPECT_NE(authCallback, nullptr);
303 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(authCallback));
304 auto service = Common::MakeShared<MockUserAuthService>();
305 EXPECT_NE(service, nullptr);
306 EXPECT_CALL(*service, Auth(_, _, _, _, _))
307 .Times(Exactly(1))
308 .WillOnce([&testCallback](int32_t apiVersion, const std::vector<uint8_t> &challenge,
__anonec45643e0b02(int32_t apiVersion, const std::vector<uint8_t> &challenge, AuthType authType, AuthTrustLevel authTrustLevel, sptr<UserAuthCallbackInterface> &callback) 309 AuthType authType, AuthTrustLevel authTrustLevel, sptr<UserAuthCallbackInterface> &callback) {
310 EXPECT_EQ(apiVersion, testApiVersion);
311 EXPECT_THAT(challenge, ElementsAre(1, 2, 3, 4));
312 EXPECT_EQ(authType, testAuthType);
313 EXPECT_EQ(authTrustLevel, testAtl);
314 EXPECT_EQ(callback, testCallback);
315 return 0;
316 });
317 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
318 ON_CALL(*obj, SendRequest)
__anonec45643e0c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 319 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
320 service->OnRemoteRequest(code, data, reply, option);
321 return SUCCESS;
322 });
323 EXPECT_EQ(proxy->Auth(testApiVersion, testChallenge, testAuthType, testAtl, testCallback), SUCCESS);
324 }
325
326 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuth002, TestSize.Level0)
327 {
328 static const int32_t testApiVersion = 0;
329 static const AuthType testAuthType = FACE;
330 static const AuthTrustLevel testAtl = ATL1;
331 const std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
332
333 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
334 EXPECT_NE(obj, nullptr);
335 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
336 EXPECT_NE(proxy, nullptr);
337 sptr<UserAuthCallbackInterface> testCallback(nullptr);
338 EXPECT_EQ(proxy->Auth(testApiVersion, testChallenge, testAuthType, testAtl, testCallback), BAD_CONTEXT_ID);
339 }
340
341 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthUser001, TestSize.Level0)
342 {
343 AuthParamInner testAuthParamInner = {
344 .userId = 200,
345 .challenge = {1, 2, 3, 4},
346 .authType = FACE,
347 .authTrustLevel = ATL1,
348 };
349 std::optional<RemoteAuthParam> testRemoteAuthParam = std::nullopt;
350
351 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
352 EXPECT_NE(obj, nullptr);
353 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
354 EXPECT_NE(proxy, nullptr);
355 auto authCallback = Common::MakeShared<MockAuthenticationCallback>();
356 EXPECT_NE(authCallback, nullptr);
357 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(authCallback));
358 auto service = Common::MakeShared<MockUserAuthService>();
359 EXPECT_NE(service, nullptr);
360 EXPECT_CALL(*service, AuthUser(_, _, _))
361 .Times(Exactly(1))
362 .WillOnce([&testCallback, &testAuthParamInner](AuthParamInner &authParam,
__anonec45643e0d02(AuthParamInner &authParam, std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) 363 std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) {
364 EXPECT_EQ(authParam.userId, testAuthParamInner.userId);
365 EXPECT_THAT(authParam.challenge, ElementsAre(1, 2, 3, 4));
366 EXPECT_EQ(authParam.authType, testAuthParamInner.authType);
367 EXPECT_EQ(authParam.authTrustLevel, testAuthParamInner.authTrustLevel);
368 EXPECT_EQ(callback, testCallback);
369 return 0;
370 });
371 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
372 ON_CALL(*obj, SendRequest)
__anonec45643e0e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 373 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
374 service->OnRemoteRequest(code, data, reply, option);
375 return SUCCESS;
376 });
377 EXPECT_EQ(proxy->AuthUser(testAuthParamInner, testRemoteAuthParam, testCallback), SUCCESS);
378 }
379
380 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthUser002, TestSize.Level0)
381 {
382 AuthParamInner testAuthParamInner = {
383 .userId = 200,
384 .challenge = {1, 2, 3, 4},
385 .authType = FACE,
386 .authTrustLevel = ATL1,
387 };
388 RemoteAuthParam param = {};
389 param.verifierNetworkId = "123";
390 param.collectorNetworkId = "1233324321423412344134";
391 param.collectorTokenId = 1233;
392 std::optional<RemoteAuthParam> testRemoteAuthParam = param;
393
394 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
395 EXPECT_NE(obj, nullptr);
396 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
397 EXPECT_NE(proxy, nullptr);
398 sptr<UserAuthCallbackInterface> testCallback(nullptr);
399 EXPECT_EQ(proxy->AuthUser(testAuthParamInner, testRemoteAuthParam, testCallback), BAD_CONTEXT_ID);
400 }
401
402 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthUser003, TestSize.Level0)
403 {
404 AuthParamInner testAuthParamInner = {
405 .userId = 200,
406 .challenge = {1, 2, 3, 4},
407 .authType = FACE,
408 .authTrustLevel = ATL1,
409 };
410 RemoteAuthParam param = {};
411 param.verifierNetworkId = "123";
412 param.collectorNetworkId = "1233324321423412344134";
413 param.collectorTokenId = 1233;
414 std::optional<RemoteAuthParam> testRemoteAuthParam = param;
415
416 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
417 EXPECT_NE(obj, nullptr);
418 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
419 EXPECT_NE(proxy, nullptr);
420 auto authCallback = Common::MakeShared<MockAuthenticationCallback>();
421 EXPECT_NE(authCallback, nullptr);
422 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(authCallback));
423 auto service = Common::MakeShared<MockUserAuthService>();
424 EXPECT_NE(service, nullptr);
425 EXPECT_CALL(*service, AuthUser(_, _, _))
426 .Times(Exactly(1))
427 .WillOnce([&testCallback, &testAuthParamInner](AuthParamInner &authParam,
__anonec45643e0f02(AuthParamInner &authParam, std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) 428 std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) {
429 EXPECT_EQ(authParam.userId, testAuthParamInner.userId);
430 EXPECT_THAT(authParam.challenge, ElementsAre(1, 2, 3, 4));
431 EXPECT_EQ(authParam.authType, testAuthParamInner.authType);
432 EXPECT_EQ(authParam.authTrustLevel, testAuthParamInner.authTrustLevel);
433 EXPECT_EQ(callback, testCallback);
434 return 0;
435 });
436 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
437 ON_CALL(*obj, SendRequest)
__anonec45643e1002(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 438 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
439 service->OnRemoteRequest(code, data, reply, option);
440 return SUCCESS;
441 });
442 EXPECT_EQ(proxy->AuthUser(testAuthParamInner, testRemoteAuthParam, testCallback), SUCCESS);
443 }
444
445 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthUser004, TestSize.Level0)
446 {
447 AuthParamInner testAuthParamInner = {
448 .userId = 200,
449 .challenge = {1, 2, 3, 4},
450 .authType = FACE,
451 .authTrustLevel = ATL1,
452 };
453 RemoteAuthParam param = {};
454 param.collectorNetworkId = "1233324321423412344134";
455 param.collectorTokenId = 1233;
456 std::optional<RemoteAuthParam> testRemoteAuthParam = param;
457
458 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
459 EXPECT_NE(obj, nullptr);
460 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
461 EXPECT_NE(proxy, nullptr);
462 auto authCallback = Common::MakeShared<MockAuthenticationCallback>();
463 EXPECT_NE(authCallback, nullptr);
464 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(authCallback));
465 EXPECT_EQ(proxy->AuthUser(testAuthParamInner, testRemoteAuthParam, testCallback), BAD_CONTEXT_ID);
466 }
467
468 HWTEST_F(UserAuthProxyTest, UserAuthProxyCancelAuthOrIdentify, TestSize.Level0)
469 {
470 static const uint64_t testContextId = 200;
471 static const int32_t testCancelReason = 0;
472
473 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
474 EXPECT_NE(obj, nullptr);
475 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
476 EXPECT_NE(proxy, nullptr);
477 auto service = Common::MakeShared<MockUserAuthService>();
478 EXPECT_NE(service, nullptr);
479 EXPECT_CALL(*service, CancelAuthOrIdentify(_, _))
480 .Times(Exactly(1))
__anonec45643e1102(uint64_t contextId, int32_t cancelReason) 481 .WillOnce([](uint64_t contextId, int32_t cancelReason) {
482 EXPECT_EQ(contextId, testContextId);
483 EXPECT_EQ(cancelReason, testCancelReason);
484 return SUCCESS;
485 });
486 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
487 ON_CALL(*obj, SendRequest)
__anonec45643e1202(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 488 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
489 service->OnRemoteRequest(code, data, reply, option);
490 return SUCCESS;
491 });
492 proxy->CancelAuthOrIdentify(testContextId, testCancelReason);
493 }
494
495 HWTEST_F(UserAuthProxyTest, UserAuthProxyIdentify001, TestSize.Level0)
496 {
497 static const AuthType testAuthType = FACE;
498 const std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
499
500 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
501 EXPECT_NE(obj, nullptr);
502 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
503 EXPECT_NE(proxy, nullptr);
504 auto identifyCallback = Common::MakeShared<MockIdentificationCallback>();
505 EXPECT_NE(identifyCallback, nullptr);
506 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(identifyCallback));
507 auto service = Common::MakeShared<MockUserAuthService>();
508 EXPECT_NE(service, nullptr);
509 EXPECT_CALL(*service, Identify(_, _, _))
510 .Times(Exactly(1))
511 .WillOnce([&testCallback](const std::vector<uint8_t> &challenge, AuthType authType,
__anonec45643e1302(const std::vector<uint8_t> &challenge, AuthType authType, sptr<UserAuthCallbackInterface> &callback) 512 sptr<UserAuthCallbackInterface> &callback) {
513 EXPECT_THAT(challenge, ElementsAre(1, 2, 3, 4));
514 EXPECT_EQ(authType, testAuthType);
515 EXPECT_EQ(callback, testCallback);
516 return 0;
517 });
518 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
519 ON_CALL(*obj, SendRequest)
__anonec45643e1402(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 520 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
521 service->OnRemoteRequest(code, data, reply, option);
522 return SUCCESS;
523 });
524 EXPECT_EQ(proxy->Identify(testChallenge, testAuthType, testCallback), SUCCESS);
525 }
526
527 HWTEST_F(UserAuthProxyTest, UserAuthProxyIdentify002, TestSize.Level0)
528 {
529 static const AuthType testAuthType = FACE;
530 const std::vector<uint8_t> testChallenge = {1, 2, 3, 4};
531
532 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
533 EXPECT_NE(obj, nullptr);
534 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
535 EXPECT_NE(proxy, nullptr);
536 sptr<UserAuthCallbackInterface> testCallback(nullptr);
537 EXPECT_EQ(proxy->Identify(testChallenge, testAuthType, testCallback), BAD_CONTEXT_ID);
538 }
539
540 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthWidget001, TestSize.Level0)
541 {
542 static const int32_t testApiVersion = 0;
543 AuthParamInner authParam;
544 WidgetParamInner widgetParam;
545
546 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
547 EXPECT_NE(obj, nullptr);
548 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
549 EXPECT_NE(proxy, nullptr);
550 auto identifyCallback = Common::MakeShared<MockIdentificationCallback>();
551 EXPECT_NE(identifyCallback, nullptr);
552 sptr<UserAuthCallbackInterface> testCallback =
553 new (std::nothrow) UserAuthCallbackService(identifyCallback);
554 auto service = Common::MakeShared<MockUserAuthService>();
555 EXPECT_NE(service, nullptr);
556 sptr<ModalCallbackInterface> testModalCallback = new MockModalCallback();
557 EXPECT_NE(testModalCallback, nullptr);
558 auto *mockModalCallback = static_cast<MockModalCallback *>(testModalCallback.GetRefPtr());
559 EXPECT_NE(mockModalCallback, nullptr);
560 EXPECT_CALL(*mockModalCallback, SendCommand(_, _)).Times(0);
561 EXPECT_CALL(*service, AuthWidget(_, _, _, _, _))
562 .Times(Exactly(1))
563 .WillOnce([&testCallback, &testModalCallback](int32_t apiVersion, const AuthParamInner &authParam,
564 const WidgetParamInner &widgetParam, sptr<UserAuthCallbackInterface> &callback,
__anonec45643e1502(int32_t apiVersion, const AuthParamInner &authParam, const WidgetParamInner &widgetParam, sptr<UserAuthCallbackInterface> &callback, sptr<ModalCallbackInterface> &modalCallback) 565 sptr<ModalCallbackInterface> &modalCallback) {
566 EXPECT_EQ(apiVersion, testApiVersion);
567 EXPECT_EQ(callback, testCallback);
568 EXPECT_EQ(modalCallback, testModalCallback);
569 return 0;
570 });
571 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
572 ON_CALL(*obj, SendRequest)
__anonec45643e1602(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 573 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
574 service->OnRemoteRequest(code, data, reply, option);
575 return SUCCESS;
576 });
577 proxy->AuthWidget(testApiVersion, authParam, widgetParam, testCallback, testModalCallback);
578 }
579
580 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthWidget002, TestSize.Level0)
581 {
582 static const int32_t testApiVersion = 0;
583 AuthParamInner authParam;
584 WidgetParamInner widgetParam;
585
586 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
587 EXPECT_NE(obj, nullptr);
588 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
589 EXPECT_NE(proxy, nullptr);
590 sptr<UserAuthCallbackInterface> testCallback(nullptr);
591 sptr<ModalCallbackInterface> testModalCallback(nullptr);
592 proxy->AuthWidget(testApiVersion, authParam, widgetParam, testCallback, testModalCallback);
593 }
594
595 HWTEST_F(UserAuthProxyTest, UserAuthProxyAuthWidget003, TestSize.Level0)
596 {
597 static const int32_t testApiVersion = 0;
598 AuthParamInner authParam;
599 authParam.authTypes.push_back(PIN);
600 authParam.reuseUnlockResult.isReuse = true;
601 WidgetParamInner widgetParam;
602
603 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
604 EXPECT_NE(obj, nullptr);
605 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
606 EXPECT_NE(proxy, nullptr);
607 auto identifyCallback = Common::MakeShared<MockIdentificationCallback>();
608 EXPECT_NE(identifyCallback, nullptr);
609 sptr<UserAuthCallbackInterface> testCallback =
610 new (std::nothrow) UserAuthCallbackService(identifyCallback);
611 auto service = Common::MakeShared<MockUserAuthService>();
612 EXPECT_NE(service, nullptr);
613 sptr<ModalCallbackInterface> testModalCallback = new MockModalCallback();
614 EXPECT_NE(testModalCallback, nullptr);
615 auto *mockModalCallback = static_cast<MockModalCallback *>(testModalCallback.GetRefPtr());
616 EXPECT_NE(mockModalCallback, nullptr);
617 EXPECT_CALL(*mockModalCallback, SendCommand(_, _)).Times(0);
618 EXPECT_CALL(*service, AuthWidget(_, _, _, _, _))
619 .Times(Exactly(1))
620 .WillOnce([&testCallback, &testModalCallback](int32_t apiVersion, const AuthParamInner &authParam,
621 const WidgetParamInner &widgetParam, sptr<UserAuthCallbackInterface> &callback,
__anonec45643e1702(int32_t apiVersion, const AuthParamInner &authParam, const WidgetParamInner &widgetParam, sptr<UserAuthCallbackInterface> &callback, sptr<ModalCallbackInterface> &modalCallback) 622 sptr<ModalCallbackInterface> &modalCallback) {
623 EXPECT_EQ(apiVersion, testApiVersion);
624 EXPECT_EQ(callback, testCallback);
625 EXPECT_EQ(modalCallback, testModalCallback);
626 return 0;
627 });
628 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
629 ON_CALL(*obj, SendRequest)
__anonec45643e1802(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 630 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
631 service->OnRemoteRequest(code, data, reply, option);
632 return SUCCESS;
633 });
634 EXPECT_EQ(proxy->AuthWidget(testApiVersion, authParam, widgetParam, testCallback, testModalCallback), SUCCESS);
635 }
636
637 HWTEST_F(UserAuthProxyTest, UserAuthProxyNotice001, TestSize.Level0)
638 {
639 static const NoticeType testNoticeType = NoticeType::WIDGET_NOTICE;
640 static const std::string testEventData = "notice";
641
642 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
643 EXPECT_NE(obj, nullptr);
644 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
645 EXPECT_NE(proxy, nullptr);
646
647 auto service = Common::MakeShared<MockUserAuthService>();
648 EXPECT_NE(service, nullptr);
649 EXPECT_CALL(*service, Notice(_, _))
650 .Times(Exactly(1))
__anonec45643e1902(NoticeType noticeType, const std::string &eventData) 651 .WillOnce([](NoticeType noticeType, const std::string &eventData) {
652 EXPECT_EQ(noticeType, testNoticeType);
653 EXPECT_EQ(eventData, testEventData);
654 return 0;
655 });
656 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
657 ON_CALL(*obj, SendRequest)
__anonec45643e1a02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 658 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
659 service->OnRemoteRequest(code, data, reply, option);
660 return SUCCESS;
661 });
662 proxy->Notice(testNoticeType, testEventData);
663 }
664
665 HWTEST_F(UserAuthProxyTest, UserAuthProxyRegisterWidgetCallback001, TestSize.Level0)
666 {
667 static const int32_t testVersion = 0;
668
669 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
670 EXPECT_NE(obj, nullptr);
671 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
672 EXPECT_NE(proxy, nullptr);
673
674 auto identifyCallback = Common::MakeShared<MockIUserAuthWidgetCallback>();
675 EXPECT_NE(identifyCallback, nullptr);
676 sptr<WidgetCallbackInterface> testCallback =
677 new (std::nothrow) WidgetCallbackService(identifyCallback);
678 auto service = Common::MakeShared<MockUserAuthService>();
679 EXPECT_NE(service, nullptr);
680 EXPECT_CALL(*service, RegisterWidgetCallback(_, _))
681 .Times(Exactly(1))
__anonec45643e1b02(int32_t version, sptr<WidgetCallbackInterface> &callback) 682 .WillOnce([&testCallback](int32_t version, sptr<WidgetCallbackInterface> &callback) {
683 EXPECT_EQ(version, testVersion);
684 EXPECT_EQ(callback, testCallback);
685 return 0;
686 });
687 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
688 ON_CALL(*obj, SendRequest)
__anonec45643e1c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 689 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
690 service->OnRemoteRequest(code, data, reply, option);
691 return SUCCESS;
692 });
693 proxy->RegisterWidgetCallback(testVersion, testCallback);
694 }
695
696 HWTEST_F(UserAuthProxyTest, UserAuthProxyRegisterWidgetCallback002, TestSize.Level0)
697 {
698 static const int32_t testVersion = 0;
699
700 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
701 EXPECT_NE(obj, nullptr);
702 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
703 EXPECT_NE(proxy, nullptr);
704 sptr<WidgetCallbackInterface> callback(nullptr);
705 EXPECT_EQ(proxy->RegisterWidgetCallback(testVersion, callback), GENERAL_ERROR);
706 }
707
708 HWTEST_F(UserAuthProxyTest, UserAuthProxyRegistUserAuthSuccessEventListener001, TestSize.Level0)
709 {
710 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
711 EXPECT_NE(obj, nullptr);
712 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
713 EXPECT_NE(proxy, nullptr);
714
715 sptr<AuthEventListenerInterface> testCallback = new (std::nothrow) MockAuthEventListenerService();
716 auto service = Common::MakeShared<MockUserAuthService>();
717 EXPECT_NE(service, nullptr);
718 EXPECT_CALL(*service, RegistUserAuthSuccessEventListener(_, _))
719 .Times(Exactly(1))
__anonec45643e1d02(const std::vector<AuthType> &authType, const sptr<AuthEventListenerInterface> &callback) 720 .WillOnce([](const std::vector<AuthType> &authType, const sptr<AuthEventListenerInterface> &callback) {
721 return SUCCESS;
722 });
723 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
724 ON_CALL(*obj, SendRequest)
__anonec45643e1e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 725 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
726 service->OnRemoteRequest(code, data, reply, option);
727 return SUCCESS;
728 });
729 std::vector<AuthType> authTypeList;
730 authTypeList.push_back(AuthType::PIN);
731 authTypeList.push_back(AuthType::FACE);
732 authTypeList.push_back(AuthType::FINGERPRINT);
733 proxy->RegistUserAuthSuccessEventListener(authTypeList, testCallback);
734 }
735
736 HWTEST_F(UserAuthProxyTest, UserAuthProxyRegistUserAuthSuccessEventListener002, TestSize.Level0)
737 {
738 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
739 EXPECT_NE(obj, nullptr);
740 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
741 EXPECT_NE(proxy, nullptr);
742
743 std::vector<AuthType> authTypeList;
744 authTypeList.push_back(AuthType::PIN);
745 authTypeList.push_back(AuthType::FACE);
746 authTypeList.push_back(AuthType::FINGERPRINT);
747 EXPECT_EQ(proxy->RegistUserAuthSuccessEventListener(authTypeList, nullptr), GENERAL_ERROR);
748 }
749
750 HWTEST_F(UserAuthProxyTest, UserAuthProxyUnRegistUserAuthSuccessEventListener001, TestSize.Level0)
751 {
752 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
753 EXPECT_NE(obj, nullptr);
754 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
755 EXPECT_NE(proxy, nullptr);
756
757 sptr<AuthEventListenerInterface> testCallback = new (std::nothrow) MockAuthEventListenerService();
758 auto service = Common::MakeShared<MockUserAuthService>();
759 EXPECT_NE(service, nullptr);
760 EXPECT_CALL(*service, UnRegistUserAuthSuccessEventListener(_))
761 .Times(Exactly(1))
__anonec45643e1f02(const sptr<AuthEventListenerInterface> &callback) 762 .WillOnce([](const sptr<AuthEventListenerInterface> &callback) {
763 return SUCCESS;
764 });
765 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
766 ON_CALL(*obj, SendRequest)
__anonec45643e2002(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 767 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
768 service->OnRemoteRequest(code, data, reply, option);
769 return SUCCESS;
770 });
771 proxy->UnRegistUserAuthSuccessEventListener(testCallback);
772 }
773
774 HWTEST_F(UserAuthProxyTest, UserAuthProxyUnRegistUserAuthSuccessEventListener002, TestSize.Level0)
775 {
776 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
777 EXPECT_NE(obj, nullptr);
778 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
779 EXPECT_NE(proxy, nullptr);
780
781 EXPECT_EQ(proxy->UnRegistUserAuthSuccessEventListener(nullptr), GENERAL_ERROR);
782 }
783
784 HWTEST_F(UserAuthProxyTest, UserAuthProxySetGlobalConfigParam001, TestSize.Level0)
785 {
786 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
787 EXPECT_NE(obj, nullptr);
788 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
789 EXPECT_NE(proxy, nullptr);
790
791 auto service = Common::MakeShared<MockUserAuthService>();
792 EXPECT_NE(service, nullptr);
793 ON_CALL(*obj, SendRequest)
__anonec45643e2102(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 794 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
795 service->OnRemoteRequest(code, data, reply, option);
796 return SUCCESS;
797 });
798 GlobalConfigParam param = {};
799 EXPECT_EQ(proxy->SetGlobalConfigParam(param), INVALID_PARAMETERS);
800 }
801
802 HWTEST_F(UserAuthProxyTest, UserAuthProxySetGlobalConfigParam002, TestSize.Level0)
803 {
804 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
805 EXPECT_NE(obj, nullptr);
806 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
807 EXPECT_NE(proxy, nullptr);
808
809 auto service = Common::MakeShared<MockUserAuthService>();
810 EXPECT_NE(service, nullptr);
811 EXPECT_CALL(*service, SetGlobalConfigParam(_))
812 .Times(Exactly(1))
__anonec45643e2202(const GlobalConfigParam ¶m) 813 .WillOnce([](const GlobalConfigParam ¶m) {
814 return SUCCESS;
815 });
816 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
817 ON_CALL(*obj, SendRequest)
__anonec45643e2302(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 818 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
819 service->OnRemoteRequest(code, data, reply, option);
820 return GENERAL_ERROR;
821 });
822 GlobalConfigParam param = {};
823 param.type = PIN_EXPIRED_PERIOD;
824 param.value.pinExpiredPeriod = 1;
825 EXPECT_EQ(proxy->SetGlobalConfigParam(param), GENERAL_ERROR);
826 }
827
828 HWTEST_F(UserAuthProxyTest, UserAuthProxySetGlobalConfigParam003, TestSize.Level0)
829 {
830 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
831 EXPECT_NE(obj, nullptr);
832 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
833 EXPECT_NE(proxy, nullptr);
834
835 auto service = Common::MakeShared<MockUserAuthService>();
836 EXPECT_NE(service, nullptr);
837 EXPECT_CALL(*service, SetGlobalConfigParam(_))
838 .Times(Exactly(1))
__anonec45643e2402(const GlobalConfigParam ¶m) 839 .WillOnce([](const GlobalConfigParam ¶m) {
840 return GENERAL_ERROR;
841 });
842 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
843 ON_CALL(*obj, SendRequest)
__anonec45643e2502(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 844 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
845 service->OnRemoteRequest(code, data, reply, option);
846 return SUCCESS;
847 });
848 GlobalConfigParam param = {};
849 param.type = ENABLE_STATUS;
850 param.value.enableStatus = true;
851 EXPECT_EQ(proxy->SetGlobalConfigParam(param), GENERAL_ERROR);
852 }
853
854 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetPropertyById001, TestSize.Level0)
855 {
856 static const uint64_t testCredentialId = 1;
857 std::vector<Attributes::AttributeKey> testKeys = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
858 Attributes::ATTR_SCHEDULE_MODE};
859
860 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
861 EXPECT_NE(obj, nullptr);
862 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
863 EXPECT_NE(proxy, nullptr);
864 auto getPropCallback = Common::MakeShared<MockGetPropCallback>();
865 EXPECT_NE(getPropCallback, nullptr);
866 sptr<GetExecutorPropertyCallbackInterface> testCallback(
867 new (std::nothrow) GetExecutorPropertyCallbackService(getPropCallback));
868 auto service = Common::MakeShared<MockUserAuthService>();
869 EXPECT_NE(service, nullptr);
870 EXPECT_CALL(*service, GetPropertyById(_, _, _))
871 .Times(Exactly(1))
872 .WillOnce([&testCallback](uint64_t credentialId,
__anonec45643e2602(uint64_t credentialId, const std::vector<Attributes::AttributeKey> &keys, sptr<GetExecutorPropertyCallbackInterface> &callback) 873 const std::vector<Attributes::AttributeKey> &keys, sptr<GetExecutorPropertyCallbackInterface> &callback) {
874 EXPECT_EQ(credentialId, testCredentialId);
875 EXPECT_THAT(keys, ElementsAre(Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
876 Attributes::ATTR_SCHEDULE_MODE));
877 EXPECT_EQ(callback, testCallback);
878 });
879 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
880 ON_CALL(*obj, SendRequest)
__anonec45643e2702(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 881 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
882 service->OnRemoteRequest(code, data, reply, option);
883 return SUCCESS;
884 });
885 proxy->GetPropertyById(testCredentialId, testKeys, testCallback);
886 }
887
888 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetPropertyById002, TestSize.Level0)
889 {
890 static const uint64_t testCredentialId = 1;
891 std::vector<Attributes::AttributeKey> testKeys = {};
892
893 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
894 EXPECT_NE(obj, nullptr);
895 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
896 EXPECT_NE(proxy, nullptr);
897 sptr<GetExecutorPropertyCallbackInterface> testCallback(nullptr);
898 proxy->GetPropertyById(testCredentialId, testKeys, testCallback);
899 }
900
901 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetPropertyById003, TestSize.Level0)
902 {
903 static const uint64_t testCredentialId = 1;
904 std::vector<Attributes::AttributeKey> testKeys = {};
905
906 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
907 EXPECT_NE(obj, nullptr);
908 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
909 EXPECT_NE(proxy, nullptr);
910 auto getPropCallback = Common::MakeShared<MockGetPropCallback>();
911 EXPECT_NE(getPropCallback, nullptr);
912 sptr<GetExecutorPropertyCallbackInterface> testCallback(
913 new (std::nothrow) GetExecutorPropertyCallbackService(getPropCallback));
914 proxy->GetPropertyById(testCredentialId, testKeys, testCallback);
915 }
916
917
918 HWTEST_F(UserAuthProxyTest, UserAuthProxyGetPropertyById004, TestSize.Level0)
919 {
920 static const uint64_t testCredentialId = 1;
921 std::vector<Attributes::AttributeKey> testKeys = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
922 Attributes::ATTR_SCHEDULE_MODE};
923 testKeys.resize(513);
924
925 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
926 EXPECT_NE(obj, nullptr);
927 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
928 EXPECT_NE(proxy, nullptr);
929 auto getPropCallback = Common::MakeShared<MockGetPropCallback>();
930 EXPECT_NE(getPropCallback, nullptr);
931 sptr<GetExecutorPropertyCallbackInterface> testCallback(
932 new (std::nothrow) GetExecutorPropertyCallbackService(getPropCallback));
933 proxy->GetPropertyById(testCredentialId, testKeys, testCallback);
934 }
935
936 HWTEST_F(UserAuthProxyTest, UserAuthProxyPrepareRemoteAuth001, TestSize.Level0)
937 {
938 const std::string networkId = "123456";
939
940 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
941 EXPECT_NE(obj, nullptr);
942 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
943 EXPECT_NE(proxy, nullptr);
944 auto authCallback = Common::MakeShared<MockAuthenticationCallback>();
945 EXPECT_NE(authCallback, nullptr);
946 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(authCallback));
947 auto service = Common::MakeShared<MockUserAuthService>();
948 EXPECT_NE(service, nullptr);
949 EXPECT_CALL(*service, PrepareRemoteAuth(_, _))
950 .Times(Exactly(1))
__anonec45643e2802(const std::string &networkId, sptr<UserAuthCallbackInterface> &callback) 951 .WillOnce([&testCallback](const std::string &networkId, sptr<UserAuthCallbackInterface> &callback) {
952 EXPECT_EQ(callback, testCallback);
953 return 0;
954 });
955 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
956 ON_CALL(*obj, SendRequest)
__anonec45643e2902(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 957 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
958 service->OnRemoteRequest(code, data, reply, option);
959 return SUCCESS;
960 });
961 EXPECT_EQ(proxy->PrepareRemoteAuth(networkId, testCallback), SUCCESS);
962 }
963
964 HWTEST_F(UserAuthProxyTest, UserAuthProxyPrepareRemoteAuth002, TestSize.Level0)
965 {
966 const std::string networkId = "123456";
967
968 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
969 EXPECT_NE(obj, nullptr);
970 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
971 EXPECT_NE(proxy, nullptr);
972 sptr<UserAuthCallbackInterface> testCallback(nullptr);
973 EXPECT_EQ(proxy->PrepareRemoteAuth(networkId, testCallback), GENERAL_ERROR);
974 }
975
976 HWTEST_F(UserAuthProxyTest, UserAuthProxyPrepareRemoteAuth003, TestSize.Level0)
977 {
978 const std::string networkId = "123456";
979
980 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
981 EXPECT_NE(obj, nullptr);
982 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
983 EXPECT_NE(proxy, nullptr);
984 auto authCallback = Common::MakeShared<MockAuthenticationCallback>();
985 EXPECT_NE(authCallback, nullptr);
986 sptr<UserAuthCallbackInterface> testCallback(new (std::nothrow) UserAuthCallbackService(authCallback));
987 auto service = Common::MakeShared<MockUserAuthService>();
988 EXPECT_NE(service, nullptr);
989 EXPECT_CALL(*service, PrepareRemoteAuth(_, _))
990 .Times(Exactly(1))
__anonec45643e2a02(const std::string &networkId, sptr<UserAuthCallbackInterface> &callback) 991 .WillOnce([&testCallback](const std::string &networkId, sptr<UserAuthCallbackInterface> &callback) {
992 EXPECT_EQ(callback, testCallback);
993 return 0;
994 });
995 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
996 ON_CALL(*obj, SendRequest)
__anonec45643e2b02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 997 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
998 service->OnRemoteRequest(code, data, reply, option);
999 return GENERAL_ERROR;
1000 });
1001 EXPECT_EQ(proxy->PrepareRemoteAuth(networkId, testCallback), GENERAL_ERROR);
1002 }
1003
1004 HWTEST_F(UserAuthProxyTest, UserAuthProxyVerifyAuthToken001, TestSize.Level0)
1005 {
1006 std::vector<uint8_t> testTokenIn = {};
1007 uint64_t testAllowableDuration = 0;
1008
1009 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1010 EXPECT_NE(obj, nullptr);
1011 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
1012 EXPECT_NE(proxy, nullptr);
1013
1014 auto callback = Common::MakeShared<MockVerifyTokenCallback>();
1015 EXPECT_NE(callback, nullptr);
1016 sptr<VerifyTokenCallbackInterface> testCallback =
1017 new (std::nothrow) VerifyTokenCallbackService(callback);
1018
1019 auto service = Common::MakeShared<MockUserAuthService>();
1020 EXPECT_NE(service, nullptr);
1021 EXPECT_CALL(*service, VerifyAuthToken(_, _, _)).Times(Exactly(1));
1022 ON_CALL(*service, VerifyAuthToken)
1023 .WillByDefault(
1024 [&testTokenIn, &testAllowableDuration, &testCallback]
1025 (const std::vector<uint8_t> &tokenIn, uint64_t allowableDuration,
__anonec45643e2c02(const std::vector<uint8_t> &tokenIn, uint64_t allowableDuration, const sptr<VerifyTokenCallbackInterface> &callback) 1026 const sptr<VerifyTokenCallbackInterface> &callback) {
1027 EXPECT_EQ(testTokenIn, tokenIn);
1028 EXPECT_EQ(testAllowableDuration, allowableDuration);
1029 }
1030 );
1031
1032 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
1033 ON_CALL(*obj, SendRequest)
__anonec45643e2d02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 1034 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
1035 service->OnRemoteRequest(code, data, reply, option);
1036 return SUCCESS;
1037 });
1038 proxy->VerifyAuthToken(testTokenIn, testAllowableDuration, testCallback);
1039 }
1040
1041 HWTEST_F(UserAuthProxyTest, UserAuthProxyVerifyAuthToken002, TestSize.Level0)
1042 {
1043 std::vector<uint8_t> testTokenIn = {};
1044 uint64_t testAllowableDuration = 0;
1045
1046 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1047 EXPECT_NE(obj, nullptr);
1048 auto proxy = Common::MakeShared<UserAuthProxy>(obj);
1049 EXPECT_NE(proxy, nullptr);
1050
1051 sptr<VerifyTokenCallbackInterface> testCallback = new (std::nothrow) VerifyTokenCallbackService(nullptr);
1052 proxy->VerifyAuthToken(testTokenIn, testAllowableDuration, testCallback);
1053 }
1054 } // namespace UserAuth
1055 } // namespace UserIam
1056 } // namespace OHOS