1 /*
2 * Copyright (c) 2022-2025 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 "accesstoken_kit.h"
17 #define private public
18 #include "account_iam_callback_service.h"
19 #undef private
20 #include "account_iam_client.h"
21 #include "account_iam_client_test_callback.h"
22 #include "account_log_wrapper.h"
23 #include "account_test_common.h"
24 #include "ipc_skeleton.h"
25 #include "test_common.h"
26 #include "token_setproc.h"
27
28 namespace OHOS {
29 namespace AccountTest {
30 namespace {
31 const int32_t TEST_USER_ID = 200;
32 const int32_t WAIT_TIME = 20;
33 static uint64_t g_selfTokenID;
34 }
35
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace OHOS::AccountSA;
39 using namespace OHOS::Security::AccessToken;
40
41 #ifdef HAS_PIN_AUTH_PART
42 class MockIInputer : public OHOS::AccountSA::IInputer {
43 public:
~MockIInputer()44 virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)45 void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
46 std::shared_ptr<IInputerData> inputerData) override
47 {
48 return;
49 }
50 };
51 #endif
52
53 class AccountIAMCallbackServiceTest : public testing::Test {
54 public:
55 static void SetUpTestCase(void);
56 static void TearDownTestCase(void);
57 void SetUp(void) override;
58 void TearDown(void) override;
59 };
60
SetUpTestCase(void)61 void AccountIAMCallbackServiceTest::SetUpTestCase(void)
62 {
63 g_selfTokenID = IPCSkeleton::GetSelfTokenID();
64 ASSERT_EQ(0, SetSelfTokenID(GetTokenIdFromBundleName("com.ohos.settings")));
65 }
66
TearDownTestCase(void)67 void AccountIAMCallbackServiceTest::TearDownTestCase(void)
68 {
69 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenID));
70 }
71
SetUp(void)72 void AccountIAMCallbackServiceTest::SetUp(void) __attribute__((no_sanitize("cfi")))
73 {
74 testing::UnitTest *test = testing::UnitTest::GetInstance();
75 ASSERT_NE(test, nullptr);
76 const testing::TestInfo *testinfo = test->current_test_info();
77 ASSERT_NE(testinfo, nullptr);
78 string testCaseName = string(testinfo->name());
79 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
80 }
81
TearDown(void)82 void AccountIAMCallbackServiceTest::TearDown(void)
83 {}
84
85 /**
86 * @tc.name: IDMCallbackService_OnAcquireInfo_0100
87 * @tc.desc: OnAcquireInfo with nullptr.
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_OnAcquireInfo_0100, TestSize.Level3)
92 {
93 sptr<IDMCallbackService> wrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, nullptr);
94 EXPECT_TRUE(wrapper->callback_ == nullptr);
95 Attributes extraInfo;
96 wrapper->OnAcquireInfo(0, 0, extraInfo.Serialize());
97 }
98
99 /**
100 * @tc.name: IDMCallbackService_OnAcquireInfo_0200
101 * @tc.desc: OnAcquireInfo with not nullptr.
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_OnAcquireInfo_0200, TestSize.Level3)
106 {
107 auto callback = std::make_shared<MockIDMCallback>();
108 EXPECT_NE(callback, nullptr);
109 EXPECT_CALL(*callback, OnAcquireInfo(_, _, _)).Times(Exactly(1));
110 auto testCallback = std::make_shared<TestIDMCallback>(callback);
111 sptr<IDMCallbackService> wrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, testCallback);
112 EXPECT_TRUE(wrapper->callback_ != nullptr);
113 Attributes extraInfo;
114 wrapper->OnAcquireInfo(0, 0, extraInfo.Serialize());
115 std::unique_lock<std::mutex> lock(testCallback->mutex);
116 testCallback->cv.wait_for(
__anon0bd6a7140202() 117 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
118 }
119
120 /**
121 * @tc.name: IDMCallbackService_OnResult_0100
122 * @tc.desc: OnResult test.
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_OnResult_0100, TestSize.Level3)
127 {
128 auto callback = std::make_shared<MockIDMCallback>();
129 EXPECT_NE(callback, nullptr);
130 EXPECT_CALL(*callback, OnResult(0, _)).Times(Exactly(1));
131 auto testCallback = std::make_shared<TestIDMCallback>(callback);
132 sptr<IDMCallbackService> wrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, testCallback);
133 ASSERT_NE(wrapper, nullptr);
134 Attributes extraInfo;
135 wrapper->OnResult(0, extraInfo.Serialize());
136 {
137 std::unique_lock<std::mutex> lock(testCallback->mutex);
138 testCallback->cv.wait_for(
__anon0bd6a7140302() 139 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
140 }
141 EXPECT_CALL(*callback, OnResult(1, _)).Times(Exactly(1));
142 testCallback->isReady = false;
143 wrapper->OnResult(1, extraInfo.Serialize());
144 {
145 std::unique_lock<std::mutex> lock(testCallback->mutex);
146 testCallback->cv.wait_for(
__anon0bd6a7140402() 147 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
148 }
149 wrapper->callback_ = nullptr;
150 wrapper->OnResult(0, extraInfo.Serialize());
151 }
152
153 /**
154 * @tc.name: GetCredInfoCallbackService_OnCredentialInfo_0100
155 * @tc.desc: OnCredentialInfo with nullptr.
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(AccountIAMCallbackServiceTest, GetCredInfoCallbackService_OnCredentialInfo_0100, TestSize.Level3)
160 {
161 sptr<GetCredInfoCallbackService> wrapper = new (std::nothrow) GetCredInfoCallbackService(nullptr);
162 EXPECT_TRUE(wrapper->callback_ == nullptr);
163 std::vector<CredentialInfoIam> infoList;
164 wrapper->OnCredentialInfo(0, infoList);
165 }
166
167 /**
168 * @tc.name: GetSetPropCallbackService_OnResult_0100
169 * @tc.desc: OnResult with nullptr.
170 * @tc.type: FUNC
171 * @tc.require:
172 */
173 HWTEST_F(AccountIAMCallbackServiceTest, GetSetPropCallbackService_OnResult_0100, TestSize.Level3)
174 {
175 sptr<GetSetPropCallbackService> wrapper = new (std::nothrow) GetSetPropCallbackService(nullptr);
176 EXPECT_TRUE(wrapper->callback_ == nullptr);
177 Attributes extraInfo;
178 wrapper->OnResult(0, extraInfo.Serialize());
179 }
180
181 /**
182 * @tc.name: DomainAuthCallbackAdapter_OnResult_0100
183 * @tc.desc: test OnResult.
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(AccountIAMCallbackServiceTest, DomainAuthCallbackAdapter_OnResult_0100, TestSize.Level3)
188 {
189 std::shared_ptr<DomainAuthCallbackAdapter> domainAuthCallbackAdapter =
190 std::make_shared<DomainAuthCallbackAdapter>(nullptr);
191 Parcel emptyParcel;
192 domainAuthCallbackAdapter->OnResult(0, emptyParcel);
193 std::string cmd = "hilog -x | grep 'AccountIAMFwk'";
194 std::string cmdRes = RunCommand(cmd);
195 ASSERT_TRUE(cmdRes.find("callback is nullptr") != std::string::npos);
196 }
197
198 #ifdef HAS_PIN_AUTH_PART
199 /**
200 * @tc.name: DomainCredentialRecipient_OnSetData_0100
201 * @tc.desc: test OnSetData.
202 * @tc.type: FUNC
203 * @tc.require:
204 */
205 HWTEST_F(AccountIAMCallbackServiceTest, DomainCredentialRecipient_OnSetData_0100, TestSize.Level3)
206 {
207 auto domainCredentialRecipient = new (std::nothrow) DomainCredentialRecipient(100, nullptr);
208 std::vector<uint8_t> data = {1, 2, 3, 4};
209 domainCredentialRecipient->OnSetData(0, data);
210 EXPECT_EQ(domainCredentialRecipient->idmCallback_, nullptr);
211 }
212 #endif
213
214 /**
215 * @tc.name: IDMCallbackService_DestructTest_0100
216 * @tc.desc: Test the 'IDMCallbackService' object has not been called before destructing.
217 * @tc.type: FUNC
218 * @tc.require:
219 */
220 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_DestructTest_0100, TestSize.Level3)
221 {
222 auto callback = std::make_shared<MockIDMCallback>();
223 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _)).Times(Exactly(1));
224 auto testCallback = std::make_shared<TestIDMCallback>(callback);
225 IDMCallbackService *callbackWrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, testCallback);
226 delete callbackWrapper;
227 }
228
229 /**
230 * @tc.name: IDMCallbackService_DestructTest_0200
231 * @tc.desc: Test the 'IDMCallbackService' object has been called before destructing.
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_DestructTest_0200, TestSize.Level3)
236 {
237 auto callback = std::make_shared<MockIDMCallback>();
238 EXPECT_CALL(*callback, OnResult(0, _)).Times(Exactly(1));
239 auto testCallback = std::make_shared<TestIDMCallback>(callback);
240 IDMCallbackService *callbackWrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, testCallback);
241 Attributes emptyAttributes;
242 callbackWrapper->OnResult(0, emptyAttributes.Serialize());
243 delete callbackWrapper;
244 }
245
246 /**
247 * @tc.name: GetCredInfoCallbackService_DestructTest_0100
248 * @tc.desc: Test the 'GetCredInfoCallbackService' object has not been called before destructing.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(AccountIAMCallbackServiceTest, GetCredInfoCallbackService_DestructTest_0100, TestSize.Level3)
253 {
254 auto callback = std::make_shared<MockGetCredInfoCallback>();
255 EXPECT_CALL(*callback, OnCredentialInfo(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _)).Times(Exactly(1));
256 auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
257 GetCredInfoCallbackService *callbackWrapper = new (std::nothrow) GetCredInfoCallbackService(testCallback);
258 delete callbackWrapper;
259 }
260
261 /**
262 * @tc.name: GetCredInfoCallbackService_DestructTest_0200
263 * @tc.desc: Test the 'GetCredInfoCallbackService' object has been called before destructing.
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(AccountIAMCallbackServiceTest, GetCredInfoCallbackService_DestructTest_0200, TestSize.Level3)
268 {
269 auto callback = std::make_shared<MockGetCredInfoCallback>();
270 EXPECT_CALL(*callback, OnCredentialInfo(0, _)).Times(Exactly(1));
271 auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
272 GetCredInfoCallbackService *callbackWrapper = new (std::nothrow) GetCredInfoCallbackService(testCallback);
273 std::vector<CredentialInfoIam> emptyInfoList;
274 callbackWrapper->OnCredentialInfo(0, emptyInfoList);
275 delete callbackWrapper;
276 }
277
278 /**
279 * @tc.name: GetSetPropCallbackService_DestructTest_0100
280 * @tc.desc: Test the 'GetSetPropCallbackService' object has not been called before destructing.
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(AccountIAMCallbackServiceTest, GetSetPropCallbackService_DestructTest_0100, TestSize.Level3)
285 {
286 auto callback = std::make_shared<MockGetSetPropCallback>();
287 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _)).Times(Exactly(1));
288 auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
289 GetSetPropCallbackService *callbackWrapper = new (std::nothrow) GetSetPropCallbackService(testCallback);
290 delete callbackWrapper;
291 }
292
293 /**
294 * @tc.name: GetSetPropCallbackService_DestructTest_0200
295 * @tc.desc: Test the 'GetSetPropCallbackService' object has been called before destructing.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(AccountIAMCallbackServiceTest, GetSetPropCallbackService_DestructTest_0200, TestSize.Level3)
300 {
301 auto callback = std::make_shared<MockGetSetPropCallback>();
302 EXPECT_CALL(*callback, OnResult(0, _)).Times(Exactly(1));
303 auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
304 GetSetPropCallbackService *callbackWrapper = new (std::nothrow) GetSetPropCallbackService(testCallback);
305 Attributes emptyAttributes;
306 callbackWrapper->OnResult(0, emptyAttributes.Serialize());
307 delete callbackWrapper;
308 }
309
310 /**
311 * @tc.name: GetEnrolledIdCallbackService_DestructTest_0100
312 * @tc.desc: Test the 'GetEnrolledIdCallbackService' object has not been called before destructing.
313 * @tc.type: FUNC
314 * @tc.require:
315 */
316 HWTEST_F(AccountIAMCallbackServiceTest, GetEnrolledIdCallbackService_DestructTest_0100, TestSize.Level3)
317 {
318 auto callback = std::make_shared<MockGetEnrolledIdCallback>();
319 EXPECT_CALL(*callback, OnEnrolledId(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _)).Times(Exactly(1));
320 auto testCallback = std::make_shared<TestGetEnrolledIdCallback>(callback);
321 GetEnrolledIdCallbackService *callbackWrapper = new (std::nothrow) GetEnrolledIdCallbackService(testCallback);
322 delete callbackWrapper;
323 }
324
325 /**
326 * @tc.name: GetEnrolledIdCallbackService_DestructTest_0200
327 * @tc.desc: Test the 'GetEnrolledIdCallbackService' object has been called before destructing.
328 * @tc.type: FUNC
329 * @tc.require:
330 */
331 HWTEST_F(AccountIAMCallbackServiceTest, GetEnrolledIdCallbackService_DestructTest_0200, TestSize.Level3)
332 {
333 auto callback = std::make_shared<MockGetEnrolledIdCallback>();
334 EXPECT_CALL(*callback, OnEnrolledId(0, _)).Times(Exactly(1));
335 auto testCallback = std::make_shared<TestGetEnrolledIdCallback>(callback);
336 GetEnrolledIdCallbackService *callbackWrapper = new (std::nothrow) GetEnrolledIdCallbackService(testCallback);
337 uint64_t enrolledId = 0;
338 callbackWrapper->OnEnrolledId(0, enrolledId);
339 delete callbackWrapper;
340 }
341
342 /**
343 * @tc.name: PreRemoteAuthCallbackService_DestructTest_0100
344 * @tc.desc: Test the 'PreRemoteAuthCallbackService' object has not been called before destructing.
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(AccountIAMCallbackServiceTest, PreRemoteAuthCallbackService_DestructTest_0100, TestSize.Level3)
349 {
350 auto callback = std::make_shared<MockPreRemoteAuthCallback>();
351 EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR)).Times(Exactly(1));
352 auto testCallback = std::make_shared<TestPreRemoteAuthCallback>(callback);
353 PreRemoteAuthCallbackService *callbackWrapper = new (std::nothrow) PreRemoteAuthCallbackService(testCallback);
354 delete callbackWrapper;
355 }
356
357 /**
358 * @tc.name: PreRemoteAuthCallbackService_DestructTest_0200
359 * @tc.desc: Test the 'PreRemoteAuthCallbackService' object has been called before destructing.
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(AccountIAMCallbackServiceTest, PreRemoteAuthCallbackService_DestructTest_0200, TestSize.Level3)
364 {
365 auto callback = std::make_shared<MockPreRemoteAuthCallback>();
366 EXPECT_CALL(*callback, OnResult(0)).Times(Exactly(1));
367 auto testCallback = std::make_shared<TestPreRemoteAuthCallback>(callback);
368 PreRemoteAuthCallbackService *callbackWrapper = new (std::nothrow) PreRemoteAuthCallbackService(testCallback);
369 callbackWrapper->OnResult(0);
370 delete callbackWrapper;
371 }
372 } // namespace AccountTest
373 } // namespace OHOS