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
96 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetCredInfoCallbackInterface::GetDescriptor()));
97
98 auto service = Common::MakeShared<MockIdmGetCredInfoCallbackService>();
99 EXPECT_NE(service, nullptr);
100 EXPECT_CALL(*service, OnCredentialInfos(_))
101 .WillOnce(
__anon30fe09260102(const std::vector<CredentialInfo> &credInfoList) 102 [](const std::vector<CredentialInfo> &credInfoList) {
103 EXPECT_EQ(credInfoList.size(), 0);
104 }
105 );
106
107 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
108 }
109
110 HWTEST_F(UserIdmCallbackStubTest, TestOnCredentialInfosStub_002, TestSize.Level0)
111 {
112 MessageParcel data;
113 MessageParcel reply;
114 MessageOption option(MessageOption::TF_SYNC);
115 uint32_t code = IdmGetCredInfoCallbackInterfaceCode::ON_GET_INFO;
116
117 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetCredInfoCallbackInterface::GetDescriptor()));
118 EXPECT_TRUE(data.WriteUint32(1000));
119
120 auto service = Common::MakeShared<MockIdmGetCredInfoCallbackService>();
121 EXPECT_NE(service, nullptr);
122 EXPECT_CALL(*service, OnCredentialInfos(_))
123 .WillOnce(
__anon30fe09260202(const std::vector<CredentialInfo> &credInfoList) 124 [](const std::vector<CredentialInfo> &credInfoList) {
125 EXPECT_EQ(credInfoList.size(), 0);
126 }
127 );
128
129 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
130 }
131
132 HWTEST_F(UserIdmCallbackStubTest, TestOnSecureUserInfoStub_001, TestSize.Level0)
133 {
134 MessageParcel data;
135 MessageParcel reply;
136 MessageOption option(MessageOption::TF_SYNC);
137 uint32_t code = IdmGetSecureUserInfoCallbackInterfaceCode::ON_GET_SEC_INFO;
138
139 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetSecureUserInfoCallbackInterface::GetDescriptor()));
140 auto service = Common::MakeShared<MockIdmGetSecureUserInfoCallbackService>();
141 EXPECT_NE(service, nullptr);
142 EXPECT_CALL(*service, OnSecureUserInfo(_))
143 .WillOnce(
__anon30fe09260302(const SecUserInfo &secUserInfo) 144 [](const SecUserInfo &secUserInfo) {
145 EXPECT_EQ(secUserInfo.secureUid, 0);
146 EXPECT_EQ(secUserInfo.enrolledInfo.size(), 0);
147 }
148 );
149
150 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
151 }
152
153 HWTEST_F(UserIdmCallbackStubTest, TestOnSecureUserInfoStub_002, TestSize.Level0)
154 {
155 MessageParcel data;
156 MessageParcel reply;
157 MessageOption option(MessageOption::TF_SYNC);
158 uint32_t code = IdmGetSecureUserInfoCallbackInterfaceCode::ON_GET_SEC_INFO;
159
160 EXPECT_TRUE(data.WriteInterfaceToken(IdmGetSecureUserInfoCallbackInterface::GetDescriptor()));
161 EXPECT_TRUE(data.WriteUint64(20));
162 EXPECT_TRUE(data.WriteUint32(1000));
163
164 auto service = Common::MakeShared<MockIdmGetSecureUserInfoCallbackService>();
165 EXPECT_NE(service, nullptr);
166 EXPECT_CALL(*service, OnSecureUserInfo(_))
167 .WillOnce(
__anon30fe09260402(const SecUserInfo &secUserInfo) 168 [](const SecUserInfo &secUserInfo) {
169 EXPECT_EQ(secUserInfo.secureUid, 0);
170 EXPECT_EQ(secUserInfo.enrolledInfo.size(), 0);
171 }
172 );
173
174 EXPECT_EQ(service->OnRemoteRequest(code, data, reply, option), SUCCESS);
175 }
176 } // namespace UserAuth
177 } // namespace UserIam
178 } // namespace OHOS
179