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(
__anon4d479cf20102(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(
__anon4d479cf20202(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(
__anon4d479cf20302(int32_t result, const std::vector<CredentialInfo> &credInfoList) 93 [](int32_t result, 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(
__anon4d479cf20402(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 proxy->OnCredentialInfos(SUCCESS, credInfoList);
122 }
123
124 HWTEST_F(UserIdmCallbackProxyTest, TestOnSecureUserInfo_001, TestSize.Level0)
125 {
126 auto service = Common::MakeShared<MockIdmGetSecureUserInfoCallbackService>();
127 EXPECT_NE(service, nullptr);
128 EXPECT_CALL(*service, OnSecureUserInfo(_, _))
129 .WillOnce(
__anon4d479cf20502(int32_t result, const SecUserInfo &secUserInfo) 130 [](int32_t result, const SecUserInfo &secUserInfo) {
131 EXPECT_EQ(secUserInfo.secureUid, 1000);
132 EXPECT_EQ(secUserInfo.enrolledInfo.size(), 2);
133 EXPECT_EQ(secUserInfo.enrolledInfo[0].authType, FACE);
134 EXPECT_EQ(secUserInfo.enrolledInfo[0].enrolledId, 10);
135 EXPECT_EQ(secUserInfo.enrolledInfo[1].authType, FINGERPRINT);
136 EXPECT_EQ(secUserInfo.enrolledInfo[1].enrolledId, 20);
137 }
138 );
139
140 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
141 EXPECT_NE(obj, nullptr);
142 EXPECT_CALL(*obj, SendRequest(_, _, _, _))
143 .WillOnce(
__anon4d479cf20602(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 144 [&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
145 service->OnRemoteRequest(code, data, reply, option);
146 return OHOS::NO_ERROR;
147 }
148 );
149
150 auto proxy = Common::MakeShared<IdmGetSecureUserInfoProxy>(obj);
151 EXPECT_NE(proxy, nullptr);
152
153 SecUserInfo secUserInfo = {};
154 secUserInfo.secureUid = 1000;
155 secUserInfo.enrolledInfo = {{FACE, 10}, {FINGERPRINT, 20}};
156 proxy->OnSecureUserInfo(SUCCESS, secUserInfo);
157 }
158 } // namespace UserAuth
159 } // namespace UserIam
160 } // namespace OHOS
161