1 /*
2 * Copyright (C) 2022-2023 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_proxy_test.h"
17
18 #include "iam_ptr.h"
19 #include "mock_remote_object.h"
20 #include "mock_user_idm_callback_service.h"
21 #include "user_idm_callback_proxy.h"
22 #include "widget_callback_service.h"
23
24 namespace OHOS {
25 namespace UserIam {
26 namespace UserAuth {
27 using namespace testing;
28 using namespace testing::ext;
29
SetUpTestCase()30 void UserIdmCallbackProxyTest::SetUpTestCase()
31 {
32 }
33
TearDownTestCase()34 void UserIdmCallbackProxyTest::TearDownTestCase()
35 {
36 }
37
SetUp()38 void UserIdmCallbackProxyTest::SetUp()
39 {
40 }
41
TearDown()42 void UserIdmCallbackProxyTest::TearDown()
43 {
44 }
45
46 HWTEST_F(UserIdmCallbackProxyTest, TestOnResult_001, TestSize.Level0)
47 {
48 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
49 EXPECT_NE(obj, nullptr);
50 EXPECT_CALL(*obj, SendRequest(_, _, _, _))
51 .WillOnce(
__anond00db3ea0102(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 52 [](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
53 EXPECT_EQ(code, IdmCallbackInterfaceCode::IDM_CALLBACK_ON_RESULT);
54 return OHOS::NO_ERROR;
55 }
56 );
57
58 auto proxy = Common::MakeShared<IdmCallbackProxy>(obj);
59 EXPECT_NE(proxy, nullptr);
60
61 int32_t result = 0;
62 Attributes extraInfo;
63 proxy->OnResult(result, extraInfo);
64 }
65
66 HWTEST_F(UserIdmCallbackProxyTest, TestOnAcquireInfo_001, TestSize.Level0)
67 {
68 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
69 EXPECT_NE(obj, nullptr);
70 EXPECT_CALL(*obj, SendRequest(_, _, _, _))
71 .WillOnce(
__anond00db3ea0202(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 72 [](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
73 EXPECT_EQ(code, IdmCallbackInterfaceCode::IDM_CALLBACK_ON_ACQUIRE_INFO);
74 return OHOS::NO_ERROR;
75 }
76 );
77
78 auto proxy = Common::MakeShared<IdmCallbackProxy>(obj);
79 EXPECT_NE(proxy, nullptr);
80
81 int32_t module = 10;
82 int32_t acquireInfo = 20;
83 Attributes extraInfo;
84 proxy->OnAcquireInfo(module, acquireInfo, extraInfo);
85 }
86
87 HWTEST_F(UserIdmCallbackProxyTest, TestOnCredentialInfos_001, TestSize.Level0)
88 {
89 auto service = Common::MakeShared<MockIdmGetCredInfoCallbackService>();
90 EXPECT_NE(service, nullptr);
91 EXPECT_CALL(*service, OnCredentialInfos(_))
92 .WillOnce(
__anond00db3ea0302(const std::vector<CredentialInfo> &credInfoList) 93 [](const std::vector<CredentialInfo> &credInfoList) {
94 EXPECT_EQ(credInfoList.size(), 3);
95 EXPECT_EQ(credInfoList[0].authType, PIN);
96 EXPECT_EQ(credInfoList[1].authType, FACE);
97 EXPECT_EQ(credInfoList[2].authType, FINGERPRINT);
98 EXPECT_EQ(credInfoList[0].credentialId, 10);
99 EXPECT_EQ(credInfoList[1].credentialId, 100);
100 EXPECT_EQ(credInfoList[2].credentialId, 1000);
101 }
102 );
103
104 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
105 EXPECT_NE(obj, nullptr);
106 EXPECT_CALL(*obj, SendRequest(_, _, _, _))
107 .WillOnce(
__anond00db3ea0402(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 108 [&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
109 service->OnRemoteRequest(code, data, reply, option);
110 return OHOS::NO_ERROR;
111 }
112 );
113
114 auto proxy = Common::MakeShared<IdmGetCredentialInfoProxy>(obj);
115 EXPECT_NE(proxy, nullptr);
116
117 CredentialInfo info1 = {PIN, PIN_SIX, 10, 20};
118 CredentialInfo info2 = {FACE, std::nullopt, 100, 200};
119 CredentialInfo info3 = {FINGERPRINT, std::nullopt, 1000, 2000};
120 std::vector<CredentialInfo> credInfoList = {info1, info2, info3};
121
122 proxy->OnCredentialInfos(credInfoList);
123 }
124
125 HWTEST_F(UserIdmCallbackProxyTest, TestOnSecureUserInfo_001, TestSize.Level0)
126 {
127 auto service = Common::MakeShared<MockIdmGetSecureUserInfoCallbackService>();
128 EXPECT_NE(service, nullptr);
129 EXPECT_CALL(*service, OnSecureUserInfo(_))
130 .WillOnce(
__anond00db3ea0502(const SecUserInfo &secUserInfo) 131 [](const SecUserInfo &secUserInfo) {
132 EXPECT_EQ(secUserInfo.secureUid, 1000);
133 EXPECT_EQ(secUserInfo.enrolledInfo.size(), 2);
134 EXPECT_EQ(secUserInfo.enrolledInfo[0].authType, FACE);
135 EXPECT_EQ(secUserInfo.enrolledInfo[0].enrolledId, 10);
136 EXPECT_EQ(secUserInfo.enrolledInfo[1].authType, FINGERPRINT);
137 EXPECT_EQ(secUserInfo.enrolledInfo[1].enrolledId, 20);
138 }
139 );
140
141 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
142 EXPECT_NE(obj, nullptr);
143 EXPECT_CALL(*obj, SendRequest(_, _, _, _))
144 .WillOnce(
__anond00db3ea0602(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 145 [&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
146 service->OnRemoteRequest(code, data, reply, option);
147 return OHOS::NO_ERROR;
148 }
149 );
150
151 auto proxy = Common::MakeShared<IdmGetSecureUserInfoProxy>(obj);
152 EXPECT_NE(proxy, nullptr);
153
154 SecUserInfo secUserInfo = {};
155 secUserInfo.secureUid = 1000;
156 secUserInfo.enrolledInfo = {{FACE, 10}, {FINGERPRINT, 20}};
157 proxy->OnSecureUserInfo(secUserInfo);
158 }
159 } // namespace UserAuth
160 } // namespace UserIam
161 } // namespace OHOS
162