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_stub_test.h"
17
18 #include "message_parcel.h"
19
20 #include "iam_ptr.h"
21 #include "mock_user_idm_callback_service.h"
22
23 namespace OHOS {
24 namespace UserIam {
25 namespace UserAuth {
26 using namespace testing;
27 using namespace testing::ext;
28
SetUpTestCase()29 void UserIdmCallbackStubTest::SetUpTestCase()
30 {
31 }
32
TearDownTestCase()33 void UserIdmCallbackStubTest::TearDownTestCase()
34 {
35 }
36
SetUp()37 void UserIdmCallbackStubTest::SetUp()
38 {
39 }
40
TearDown()41 void UserIdmCallbackStubTest::TearDown()
42 {
43 }
44
45 HWTEST_F(UserIdmCallbackStubTest, TestOnResultStub_001, TestSize.Level0)
46 {
47 int32_t result = 0;
48 std::vector<uint8_t> extraInfo = {1, 2, 3, 4};
49
50 MessageParcel data;
51 MessageParcel reply;
52 MessageOption option(MessageOption::TF_SYNC);
53 uint32_t code = IdmCallbackInterfaceCode::IDM_CALLBACK_ON_RESULT;
54
55 EXPECT_TRUE(data.WriteInterfaceToken(IdmCallbackInterface::GetDescriptor()));
56 EXPECT_TRUE(data.WriteInt32(result));
57 EXPECT_TRUE(data.WriteUInt8Vector(extraInfo));
58
59 auto service = Common::MakeShared<MockIdmCallbackService>();
60 EXPECT_NE(service, nullptr);
61 EXPECT_CALL(*service, OnResult(_, _)).Times(1);
62
63 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
64 }
65
66 HWTEST_F(UserIdmCallbackStubTest, TestOnAcquireInfoStub_001, TestSize.Level0)
67 {
68 int32_t module = 10;
69 int32_t acquireInfo = 20;
70 std::vector<uint8_t> extraInfo = {1, 2, 3, 4};
71
72 MessageParcel data;
73 MessageParcel reply;
74 MessageOption option(MessageOption::TF_SYNC);
75 uint32_t code = IdmCallbackInterfaceCode::IDM_CALLBACK_ON_ACQUIRE_INFO;
76
77 EXPECT_TRUE(data.WriteInterfaceToken(IdmCallbackInterface::GetDescriptor()));
78 EXPECT_TRUE(data.WriteInt32(module));
79 EXPECT_TRUE(data.WriteInt32(acquireInfo));
80 EXPECT_TRUE(data.WriteUInt8Vector(extraInfo));
81
82 auto service = Common::MakeShared<MockIdmCallbackService>();
83 EXPECT_NE(service, nullptr);
84 EXPECT_CALL(*service, OnAcquireInfo(_, _, _)).Times(1);
85
86 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
87 }
88
89 HWTEST_F(UserIdmCallbackStubTest, TestOnCredentialInfosStub_001, TestSize.Level0)
90 {
91 MessageParcel data;
92 MessageParcel reply;
93 MessageOption option(MessageOption::TF_SYNC);
94 uint32_t code = IdmGetCredInfoCallbackInterfaceCode::ON_GET_INFO;
95 int32_t result = 0;
96
97 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetCredInfoCallbackInterface::GetDescriptor()));
98 EXPECT_TRUE(data.WriteInt32(result));
99
100 auto service = Common::MakeShared<MockIdmGetCredInfoCallbackService>();
101 EXPECT_NE(service, nullptr);
102 EXPECT_CALL(*service, OnCredentialInfos(_, _))
103 .WillOnce(
__anon7a9af12e0102(int32_t result, const std::vector<CredentialInfo> &credInfoList) 104 [](int32_t result, const std::vector<CredentialInfo> &credInfoList) {
105 EXPECT_EQ(credInfoList.size(), 0);
106 }
107 );
108
109 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
110 }
111
112 HWTEST_F(UserIdmCallbackStubTest, TestOnCredentialInfosStub_002, TestSize.Level0)
113 {
114 MessageParcel data;
115 MessageParcel reply;
116 MessageOption option(MessageOption::TF_SYNC);
117 uint32_t code = IdmGetCredInfoCallbackInterfaceCode::ON_GET_INFO;
118 int32_t result = 0;
119
120 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetCredInfoCallbackInterface::GetDescriptor()));
121 EXPECT_TRUE(data.WriteInt32(result));
122 EXPECT_TRUE(data.WriteUint32(1000));
123
124 auto service = Common::MakeShared<MockIdmGetCredInfoCallbackService>();
125 EXPECT_NE(service, nullptr);
126 EXPECT_CALL(*service, OnCredentialInfos(_, _))
127 .WillOnce(
__anon7a9af12e0202(int32_t result, const std::vector<CredentialInfo> &credInfoList) 128 [](int32_t result, const std::vector<CredentialInfo> &credInfoList) {
129 EXPECT_EQ(credInfoList.size(), 0);
130 }
131 );
132
133 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
134 }
135
136 HWTEST_F(UserIdmCallbackStubTest, TestOnSecureUserInfoStub_001, TestSize.Level0)
137 {
138 MessageParcel data;
139 MessageParcel reply;
140 MessageOption option(MessageOption::TF_SYNC);
141 uint32_t code = IdmGetSecureUserInfoCallbackInterfaceCode::ON_GET_SEC_INFO;
142 int32_t result = 0;
143
144 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetSecureUserInfoCallbackInterface::GetDescriptor()));
145 EXPECT_TRUE(data.WriteInt32(result));
146 auto service = Common::MakeShared<MockIdmGetSecureUserInfoCallbackService>();
147 EXPECT_NE(service, nullptr);
148 EXPECT_CALL(*service, OnSecureUserInfo(_, _))
149 .WillOnce(
__anon7a9af12e0302(int32_t result, const SecUserInfo &secUserInfo) 150 [](int32_t result, const SecUserInfo &secUserInfo) {
151 EXPECT_EQ(secUserInfo.secureUid, 0);
152 EXPECT_EQ(secUserInfo.enrolledInfo.size(), 0);
153 }
154 );
155
156 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
157 }
158
159 HWTEST_F(UserIdmCallbackStubTest, TestOnSecureUserInfoStub_002, TestSize.Level0)
160 {
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option(MessageOption::TF_SYNC);
164 uint32_t code = IdmGetSecureUserInfoCallbackInterfaceCode::ON_GET_SEC_INFO;
165 int32_t result = 0;
166
167 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetSecureUserInfoCallbackInterface::GetDescriptor()));
168 EXPECT_TRUE(data.WriteInt32(result));
169 EXPECT_TRUE(data.WriteUint64(20));
170 EXPECT_TRUE(data.WriteUint32(1000));
171
172 auto service = Common::MakeShared<MockIdmGetSecureUserInfoCallbackService>();
173 EXPECT_NE(service, nullptr);
174 EXPECT_CALL(*service, OnSecureUserInfo(_, _))
175 .WillOnce(
__anon7a9af12e0402(int32_t result, const SecUserInfo &secUserInfo) 176 [](int32_t result, const SecUserInfo &secUserInfo) {
177 EXPECT_EQ(secUserInfo.secureUid, 0);
178 EXPECT_EQ(secUserInfo.enrolledInfo.size(), 0);
179 }
180 );
181
182 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
183 }
184 } // namespace UserAuth
185 } // namespace UserIam
186 } // namespace OHOS
187