1 /*
2 * Copyright (c) 2022 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 <gmock/gmock.h>
17 #include "accesstoken_kit.h"
18 #define private public
19 #include "account_iam_callback_service.h"
20 #undef private
21 #include "account_iam_client.h"
22 #include "account_log_wrapper.h"
23 #include "token_setproc.h"
24
25 namespace OHOS {
26 namespace AccountTest {
27 namespace {
28 const int32_t TEST_USER_ID = 200;
29 const uint64_t TEST_CONTEXT_ID = 122;
30 const std::vector<uint8_t> TEST_CHALLENGE = {1, 2, 3, 4};
31 }
32
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::AccountSA;
36 using namespace OHOS::Security::AccessToken;
37
38 class MockIDMCallback final : public IDMCallback {
39 public:
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)40 void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override
41 {
42 return;
43 }
OnResult(int32_t result,const Attributes & extraInfo)44 void OnResult(int32_t result, const Attributes &extraInfo) override
45 {
46 result_ = result;
47 return;
48 }
49
50 public:
51 int32_t result_ = -1;
52 };
53
54 class MockGetCredInfoCallback final : public GetCredInfoCallback {
55 public:
OnCredentialInfo(int32_t result,const std::vector<CredentialInfo> & infoList)56 void OnCredentialInfo(int32_t result, const std::vector<CredentialInfo> &infoList)override
57 {
58 return;
59 }
60 };
61
62 class MockGetSetPropCallback final : public GetSetPropCallback {
63 public:
OnResult(int32_t result,const Attributes & extraInfo)64 void OnResult(int32_t result, const Attributes &extraInfo) override
65 {
66 result_ = result;
67 return;
68 }
69
70 public:
71 int32_t result_ = -1;
72 };
73
74 class MockIInputer : public OHOS::AccountSA::IInputer {
75 public:
~MockIInputer()76 virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::shared_ptr<IInputerData> inputerData)77 void OnGetData(int32_t authSubType, std::shared_ptr<IInputerData> inputerData) override
78 {
79 return;
80 }
81 };
82
83 class AccountIAMClientNoPermissionTest : public testing::Test {
84 public:
85 static void SetUpTestCase(void);
86 static void TearDownTestCase(void);
87 void SetUp(void) override;
88 void TearDown(void) override;
89 };
90
SetUpTestCase(void)91 void AccountIAMClientNoPermissionTest::SetUpTestCase(void)
92 {}
93
TearDownTestCase(void)94 void AccountIAMClientNoPermissionTest::TearDownTestCase(void)
95 {}
96
SetUp(void)97 void AccountIAMClientNoPermissionTest::SetUp(void)
98 {}
99
TearDown(void)100 void AccountIAMClientNoPermissionTest::TearDown(void)
101 {}
102
103 /**
104 * @tc.name: AccountIAMClientNoPermission_OpenSession_0100
105 * @tc.desc: Open Session without permission.
106 * @tc.type: FUNC
107 * @tc.require:
108 */
109 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_OpenSession_0100, TestSize.Level0)
110 {
111 std::vector<uint8_t> challenge;
112 int32_t res = AccountIAMClient::GetInstance().OpenSession(0, challenge);
113 EXPECT_TRUE(res == ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
114 AccountIAMClient::GetInstance().CloseSession(0);
115 }
116
117 /**
118 * @tc.name: AccountIAMClientNoPermission_CloseSession_0100
119 * @tc.desc: Close Session without permission.
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_CloseSession_0100, TestSize.Level0)
124 {
125 std::vector<uint8_t> challenge;
126 int32_t res = AccountIAMClient::GetInstance().CloseSession(0);
127 EXPECT_TRUE(res == ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
128 }
129
130 /**
131 * @tc.name: AccountIAMClientNoPermission_AddCredential_0100
132 * @tc.desc: Add credential without permission.
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_AddCredential_0100, TestSize.Level0)
137 {
138 CredentialParameters testPara = {};
139 auto callback = std::make_shared<MockIDMCallback>();
140 ASSERT_NE(callback, nullptr);
141 AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, callback);
142 EXPECT_EQ(callback->result_, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
143 }
144
145 /**
146 * @tc.name: AccountIAMClientNoPermission_UpdateCredential_0100
147 * @tc.desc: Update credential without permission.
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_UpdateCredential_0100, TestSize.Level0)
152 {
153 CredentialParameters testPara = {};
154 auto callback = std::make_shared<MockIDMCallback>();
155 ASSERT_NE(callback, nullptr);
156 AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, callback);
157 EXPECT_EQ(callback->result_, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
158 }
159
160 /**
161 * @tc.name: AccountIAMClientNoPermission_Cancel_0100
162 * @tc.desc: Cancel without permission.
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_Cancel_0100, TestSize.Level0)
167 {
168 int32_t res = AccountIAMClient::GetInstance().Cancel(TEST_USER_ID);
169 EXPECT_EQ(res, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
170 }
171
172 /**
173 * @tc.name: AccountIAMClientNoPermission_DelCred_0100
174 * @tc.desc: Delete credential without permission.
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_DelCred_0100, TestSize.Level0)
179 {
180 uint64_t testCredentialId = 111;
181 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
182 auto callback = std::make_shared<MockIDMCallback>();
183 ASSERT_NE(callback, nullptr);
184 AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, callback);
185 EXPECT_EQ(callback->result_, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
186 }
187
188 /**
189 * @tc.name: AccountIAMClientNoPermission_DelUser_0100
190 * @tc.desc: Delete user without permission.
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_DelUser_0100, TestSize.Level0)
195 {
196 std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
197 auto callback = std::make_shared<MockIDMCallback>();
198 ASSERT_NE(callback, nullptr);
199 AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, callback);
200 EXPECT_EQ(callback->result_, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
201 }
202
203 /**
204 * @tc.name: AccountIAMClientNoPermission_GetCredentialInfo_0100
205 * @tc.desc: Get credential info without permission.
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetCredentialInfo_0100, TestSize.Level0)
210 {
211 auto callback = std::make_shared<MockGetCredInfoCallback>();
212 ASSERT_NE(callback, nullptr);
213 int32_t res = AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, callback);
214 EXPECT_EQ(res, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
215 }
216
217 /**
218 * @tc.name: AccountIAMClientNoPermission_GetAvailableStatus_0100
219 * @tc.desc: Get available status without permission.
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetAvailableStatus_0100, TestSize.Level0)
224 {
225 int32_t status;
226 int32_t res = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
227 EXPECT_EQ(res, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
228 }
229
230 /**
231 * @tc.name: AccountIAMClientNoPermission_GetProperty_0100
232 * @tc.desc: Get property without permission.
233 * @tc.type: FUNC
234 * @tc.require:
235 */
236 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetProperty_0100, TestSize.Level0)
237 {
238 GetPropertyRequest testRequest = {};
239 auto callback = std::make_shared<MockGetSetPropCallback>();
240 ASSERT_NE(callback, nullptr);
241 AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequest, callback);
242 }
243
244 /**
245 * @tc.name: AccountIAMClientNoPermission_SetProperty_0100
246 * @tc.desc: Set property without permission.
247 * @tc.type: FUNC
248 * @tc.require:
249 */
250 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_SetProperty_0100, TestSize.Level0)
251 {
252 SetPropertyRequest testRequest = {};
253 auto callback = std::make_shared<MockGetSetPropCallback>();
254 ASSERT_NE(callback, nullptr);
255 AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequest, callback);
256 }
257
258 /**
259 * @tc.name: AccountIAMClientNoPermission_RegisterInputer_0100
260 * @tc.desc: RegisterInputer without permission.
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_RegisterInputer_0100, TestSize.Level0)
265 {
266 std::shared_ptr<MockIInputer> inputer = std::make_shared<MockIInputer>();
267 int32_t res = AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputer);
268 EXPECT_EQ(res, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
269 AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN);
270 }
271
272 /**
273 * @tc.name: AccountIAMClientNoPermission_AuthUser_0100
274 * @tc.desc: Auth user without permission.
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_AuthUser_0100, TestSize.Level0)
279 {
280 SetPropertyRequest testRequest = {};
281 auto callback = std::make_shared<MockIDMCallback>();
282 ASSERT_NE(callback, nullptr);
283 int32_t res = AccountIAMClient::GetInstance().AuthUser(
284 TEST_USER_ID, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, callback);
285 EXPECT_EQ(res, ERR_OK);
286 }
287
288 /**
289 * @tc.name: AccountIAMClientNoPermission_Auth_0100
290 * @tc.desc: Auth current user without permission.
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_Auth_0100, TestSize.Level0)
295 {
296 SetPropertyRequest testRequest = {};
297 auto callback = std::make_shared<MockIDMCallback>();
298 ASSERT_NE(callback, nullptr);
299 int32_t res = AccountIAMClient::GetInstance().Auth(TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, callback);
300 EXPECT_EQ(res, ERR_OK);
301 }
302
303 /**
304 * @tc.name: AccountIAMClientNoPermission_CancelAuth_0100
305 * @tc.desc: Cancel authentication without permission.
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_CancelAuth_0100, TestSize.Level0)
310 {
311 int32_t res = AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID);
312 EXPECT_EQ(res, ERR_ACCOUNT_IAM_SERVICE_PERMISSION_DENIED);
313 }
314 } // namespace AccountTest
315 } // namespace OHOS