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 <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 #include "account_log_wrapper.h"
20 #include "app_mgr_constants.h"
21 #define protected public
22 #define private public
23 #include "app_account_authenticator_session_manager.h"
24 #include "app_account_authenticator_session.h"
25 #include "app_account_constants.h"
26 #include "app_account_authenticator_callback.h"
27 #undef private
28 #undef protected
29 #include "app_account_common.h"
30 #include "iservice_registry.h"
31 #include "mock_app_account_authenticator_stub.h"
32 #include "system_ability_definition.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::AccountSA;
38
39 namespace {
40 const std::string SESSION_ID = "256";
41 const std::string PARAM_VALUE = "VALUE";
42 const std::string REQUEST_NAME = "NAME";
43 const std::string STRING_OWNER = "OWNER";
44 const std::string STRING_EMPTY = "";
45 const std::int32_t INVALID_ACTION = -1;
46 }
47
48 class MockAuthenticatorCallback final : public AppAccountAuthenticatorCallbackStub {
49 public:
50 MOCK_METHOD2(OnResult, void(int32_t resultCode, const AAFwk::Want &result));
51 MOCK_METHOD1(OnRequestRedirected, void(AAFwk::Want &request));
52 MOCK_METHOD0(OnRequestContinued, void());
53 };
54
55 class AppAccountSessionModuleTest : public testing::Test {
56 public:
57 static void SetUpTestCase(void);
58 static void TearDownTestCase(void);
59 void SetUp(void) override;
60 void TearDown(void) override;
61 std::shared_ptr<AppAccountAuthenticatorSession> appAccountAuthenticatorSessionPtr_;
62 };
63
SetUpTestCase(void)64 void AppAccountSessionModuleTest::SetUpTestCase(void)
65 {}
66
TearDownTestCase(void)67 void AppAccountSessionModuleTest::TearDownTestCase(void)
68 {}
69
SetUp(void)70 void AppAccountSessionModuleTest::SetUp(void) __attribute__((no_sanitize("cfi")))
71 {
72 testing::UnitTest *test = testing::UnitTest::GetInstance();
73 ASSERT_NE(test, nullptr);
74 const testing::TestInfo *testinfo = test->current_test_info();
75 ASSERT_NE(testinfo, nullptr);
76 string testCaseName = string(testinfo->name());
77 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
78
79 AuthenticatorAction action = VERIFY_CREDENTIAL;
80 AuthenticatorSessionRequest request;
81 appAccountAuthenticatorSessionPtr_ = std::make_shared<AppAccountAuthenticatorSession>(action, request);
82 }
83
TearDown(void)84 void AppAccountSessionModuleTest::TearDown(void)
85 {}
86
87 /**
88 * @tc.name: AppAccountAuthenticateTest_Open_0100
89 * @tc.desc: test session func init and open abnormal branch.
90 * @tc.type: FUNC
91 * @tc.require:
92 */
93 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_Open_0100, TestSize.Level1)
94 {
95 ASSERT_NE(appAccountAuthenticatorSessionPtr_, nullptr);
96
97 appAccountAuthenticatorSessionPtr_->Init();
98 ASSERT_EQ(appAccountAuthenticatorSessionPtr_->isInitialized_, true);
99
100 appAccountAuthenticatorSessionPtr_->isOpened_ = true;
101 ErrCode result = appAccountAuthenticatorSessionPtr_->Open();
102 ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION);
103
104 appAccountAuthenticatorSessionPtr_->isOpened_ = false;
105 appAccountAuthenticatorSessionPtr_->isInitialized_ = false;
106 result = appAccountAuthenticatorSessionPtr_->Open();
107 ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION);
108 }
109
110 /**
111 * @tc.name: AppAccountAuthenticateTest_Close_0100
112 * @tc.desc: test session func Close proxy not is nullptr.
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_Close_0100, TestSize.Level1)
117 {
118 ASSERT_NE(appAccountAuthenticatorSessionPtr_, nullptr);
119
120 appAccountAuthenticatorSessionPtr_->authenticatorProxy_ =
121 new (std::nothrow) AccountSA::MockAppAccountAuthenticator();
122 ASSERT_NE(nullptr, appAccountAuthenticatorSessionPtr_->authenticatorProxy_);
123 ASSERT_NE(nullptr, appAccountAuthenticatorSessionPtr_->authenticatorProxy_->AsObject());
124 appAccountAuthenticatorSessionPtr_->serverDeathRecipient_ =
125 new (std::nothrow) SessionServerDeathRecipient(SESSION_ID);
126 ASSERT_NE(nullptr, appAccountAuthenticatorSessionPtr_->serverDeathRecipient_);
127 appAccountAuthenticatorSessionPtr_->isOpened_ = true;
128 appAccountAuthenticatorSessionPtr_->Close();
129 ASSERT_EQ(appAccountAuthenticatorSessionPtr_->isOpened_, false);
130 }
131
132 /**
133 * @tc.name: AppAccountAuthenticateTest_Close_0200
134 * @tc.desc: test session func Close callback not is nullptr branch.
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_Close_0200, TestSize.Level1)
139 {
140 AuthenticatorAction action = SET_AUTHENTICATOR_PROPERTIES;
141 AuthenticatorSessionRequest request;
142 request.callback = new (std::nothrow) MockAuthenticatorCallback();
143 ASSERT_NE(request.callback, nullptr);
144 ASSERT_NE(request.callback->AsObject(), nullptr);
145 auto testSessionPtr_ = std::make_shared<AppAccountAuthenticatorSession>(action, request);
146 ASSERT_NE(testSessionPtr_, nullptr);
147 testSessionPtr_->isOpened_ = true;
148 testSessionPtr_->Close();
149 ASSERT_EQ(testSessionPtr_->isOpened_, false);
150 }
151
152 /**
153 * @tc.name: AppAccountAuthenticateTest_Close_0300
154 * @tc.desc: test session func Close isConnected is true branch.
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_Close_0300, TestSize.Level1)
159 {
160 ASSERT_NE(appAccountAuthenticatorSessionPtr_, nullptr);
161 appAccountAuthenticatorSessionPtr_->isConnected_ = true;
162 appAccountAuthenticatorSessionPtr_->conn_ = new (std::nothrow) SessionConnection(SESSION_ID);
163 ASSERT_NE(appAccountAuthenticatorSessionPtr_->conn_, nullptr);
164 appAccountAuthenticatorSessionPtr_->isOpened_ = true;
165 appAccountAuthenticatorSessionPtr_->Close();
166 ASSERT_EQ(appAccountAuthenticatorSessionPtr_->isOpened_, false);
167 }
168
169 /**
170 * @tc.name: AppAccountAuthenticateTest_AddClientDeathRecipient_0100
171 * @tc.desc: test session func AddClientDeathRecipient is opened and callback is nullptr.
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_AddClientDeathRecipient_0100, TestSize.Level1)
176 {
177 AuthenticatorAction action = SET_AUTHENTICATOR_PROPERTIES;
178 AuthenticatorSessionRequest request;
179 request.callback = new (std::nothrow) MockAuthenticatorCallback();
180 ASSERT_NE(request.callback, nullptr);
181 ASSERT_NE(request.callback->AsObject(), nullptr);
182 auto testSessionPtr_ = std::make_shared<AppAccountAuthenticatorSession>(action, request);
183 ASSERT_NE(testSessionPtr_, nullptr);
184 ErrCode result = testSessionPtr_->AddClientDeathRecipient();
185 ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION);
186
187 result = testSessionPtr_->Open();
188 ASSERT_EQ(result, ERR_OK);
189 result = testSessionPtr_->AddClientDeathRecipient();
190 ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION);
191
192 result = appAccountAuthenticatorSessionPtr_->Open();
193 ASSERT_EQ(result, ERR_OK);
194 result = appAccountAuthenticatorSessionPtr_->AddClientDeathRecipient();
195 ASSERT_EQ(result, ERR_OK);
196 }
197
198 /**
199 * @tc.name: AppAccountAuthenticateTest_OnAbilityConnectDone_0100
200 * @tc.desc: test OnAbilityConnectDone with not same action and OnResult resultcode is ADD_ACCOUNT_IMPLICITLY branch.
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_OnAbilityConnectDone_0100, TestSize.Level1)
205 {
206 AuthenticatorAction action = ADD_ACCOUNT_IMPLICITLY;
207 AuthenticatorSessionRequest request;
208 auto appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
209 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
210
211 sptr<MockAppAccountAuthenticator> authenticatorProxy = new (std::nothrow) AccountSA::MockAppAccountAuthenticator();
212 ASSERT_NE(authenticatorProxy, nullptr);
213 ASSERT_NE(authenticatorProxy->AsObject(), nullptr);
214 AppExecFwk::ElementName element;
215 int resultCode = ERR_OK;
216 authenticatorProxy->status = true;
217 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
218 ASSERT_EQ(authenticatorProxy->status, false);
219 AAFwk::Want result;
220 resultCode = appAccountAuthenticatorSessionPtr->OnResult(ERR_JS_SUCCESS, result);
221 ASSERT_EQ(ERR_JS_ACCOUNT_AUTHENTICATOR_SERVICE_EXCEPTION, resultCode);
222 result.SetParam(Constants::KEY_NAME, PARAM_VALUE);
223 resultCode = appAccountAuthenticatorSessionPtr->OnResult(ERR_JS_SUCCESS, result);
224 ASSERT_EQ(ERR_JS_SUCCESS, resultCode);
225
226 action = AUTHENTICATE;
227 AuthenticatorSessionRequest request1;
228 request1.name = REQUEST_NAME;
229 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request1);
230 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
231 authenticatorProxy->status = true;
232 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
233 ASSERT_EQ(authenticatorProxy->status, false);
234 resultCode = appAccountAuthenticatorSessionPtr->OnResult(ERR_JS_SUCCESS, result);
235 ASSERT_EQ(ERR_JS_ACCOUNT_AUTHENTICATOR_SERVICE_EXCEPTION, resultCode);
236
237 action = CREATE_ACCOUNT_IMPLICITLY;
238 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
239 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
240 authenticatorProxy->status = true;
241 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
242 ASSERT_EQ(authenticatorProxy->status, false);
243
244 action = AUTH;
245 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
246 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
247 authenticatorProxy->status = true;
248 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
249 ASSERT_EQ(authenticatorProxy->status, false);
250 }
251
252 /**
253 * @tc.name: AppAccountAuthenticateTest_OnAbilityConnectDone_0200
254 * @tc.desc: test session func OnAbilityConnectDone different action.
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_OnAbilityConnectDone_0200, TestSize.Level1)
259 {
260 AuthenticatorAction action = ADD_ACCOUNT_IMPLICITLY;
261 AuthenticatorSessionRequest request;
262
263 sptr<MockAppAccountAuthenticator> authenticatorProxy = new (std::nothrow) AccountSA::MockAppAccountAuthenticator();
264 ASSERT_NE(authenticatorProxy, nullptr);
265 ASSERT_NE(authenticatorProxy->AsObject(), nullptr);
266 AppExecFwk::ElementName element;
267 action = VERIFY_CREDENTIAL;
268 int32_t resultCode = ERR_OK;
269 auto appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
270 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
271 authenticatorProxy->status = true;
272 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
273 ASSERT_EQ(authenticatorProxy->status, false);
274
275 action = CHECK_ACCOUNT_LABELS;
276 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
277 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
278 authenticatorProxy->status = true;
279 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
280 ASSERT_EQ(authenticatorProxy->status, false);
281
282 action = SET_AUTHENTICATOR_PROPERTIES;
283 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
284 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
285 authenticatorProxy->status = true;
286 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
287 ASSERT_EQ(authenticatorProxy->status, false);
288
289 action = IS_ACCOUNT_REMOVABLE;
290 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
291 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
292 authenticatorProxy->status = true;
293 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
294 ASSERT_EQ(authenticatorProxy->status, false);
295
296 action = static_cast<AuthenticatorAction>(INVALID_ACTION);
297 auto testCallBack = new (std::nothrow) MockAuthenticatorCallback();
298 ASSERT_NE(testCallBack, nullptr);
299 request.callback = testCallBack;
300 ASSERT_NE(request.callback, nullptr);
301 appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
302 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
303
304 EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(1));
305 appAccountAuthenticatorSessionPtr->OnAbilityConnectDone(element, authenticatorProxy, resultCode);
306 }
307
308 /**
309 * @tc.name: AppAccountAuthenticateTest_OnResult_0100
310 * @tc.desc: test session func OnResult action is AUTHENTICATE branch.
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_OnResult_0100, TestSize.Level1)
315 {
316 AuthenticatorAction action = AUTHENTICATE;
317 AuthenticatorSessionRequest request;
318 request.name = PARAM_VALUE;
319 AAFwk::Want result;
320 result.SetParam(Constants::KEY_NAME, PARAM_VALUE);
321 auto appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
322 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
323 int32_t resultCode = appAccountAuthenticatorSessionPtr->OnResult(ERR_JS_SUCCESS, result);
324 ASSERT_EQ(resultCode, ERR_JS_SUCCESS);
325 }
326
327 /**
328 * @tc.name: AppAccountAuthenticateTest_GetAuthenticatorCallback_0100
329 * @tc.desc: test func GetAuthenticatorCallback callerUid not equal ownerUid and callerBundleName not equal owner.
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_GetAuthenticatorCallback_0100, TestSize.Level1)
334 {
335 ASSERT_NE(appAccountAuthenticatorSessionPtr_, nullptr);
336 AuthenticatorSessionRequest request;
337 pid_t ownerUid = 1;
338 request.callerUid = ownerUid;
339 sptr<IRemoteObject> callback = nullptr;
340 ErrCode result = appAccountAuthenticatorSessionPtr_->GetAuthenticatorCallback(request, callback);
341 ASSERT_EQ(result, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
342
343 appAccountAuthenticatorSessionPtr_->ownerUid_ = ownerUid;
344 request.callerBundleName = "test";
345 result = appAccountAuthenticatorSessionPtr_->GetAuthenticatorCallback(request, callback);
346 ASSERT_EQ(result, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
347 }
348
349 /**
350 * @tc.name: AppAccountAuthenticateTest_GetAuthenticatorCallback_0200
351 * @tc.desc: test session func GetAuthenticatorCallback normal and authenticatorCb is nullptr.
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_GetAuthenticatorCallback_0200, TestSize.Level1)
356 {
357 ASSERT_NE(appAccountAuthenticatorSessionPtr_, nullptr);
358 AuthenticatorSessionRequest request;
359 pid_t ownerUid = 1;
360 sptr<IRemoteObject> callback = nullptr;
361
362 AuthenticatorSessionRequest request1;
363 AuthenticatorAction action = SET_AUTHENTICATOR_PROPERTIES;
364 request1.owner = STRING_OWNER;
365 auto appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request1);
366 ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
367 appAccountAuthenticatorSessionPtr->ownerUid_ = ownerUid;
368 request.callerBundleName = STRING_OWNER;
369 request.callerUid = ownerUid;
370 appAccountAuthenticatorSessionPtr->authenticatorCb_ = nullptr;
371 ErrCode result = appAccountAuthenticatorSessionPtr->GetAuthenticatorCallback(request, callback);
372 ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_AUTHENTICATOR_CALLBACK_NOT_EXIST);
373
374 appAccountAuthenticatorSessionPtr->authenticatorCb_ = new (std::nothrow) MockAuthenticatorCallback();
375 ASSERT_NE(appAccountAuthenticatorSessionPtr->authenticatorCb_, nullptr);
376 result = appAccountAuthenticatorSessionPtr->GetAuthenticatorCallback(request, callback);
377 ASSERT_EQ(result, ERR_OK);
378 ASSERT_EQ(callback, appAccountAuthenticatorSessionPtr->authenticatorCb_->AsObject());
379 }
380
381 /**
382 * @tc.name: AppAccountSessionModuleTest_GOnRemoteDied_0100
383 * @tc.desc: test session func OnRemoteDied.
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_OnRemoteDied_0100, TestSize.Level1)
388 {
389 std::string sessionId = "sessionId";
390 SessionServerDeathRecipient testSessionServerDeathRecipient(sessionId);
391 testSessionServerDeathRecipient.OnRemoteDied(nullptr);
392 ASSERT_EQ(testSessionServerDeathRecipient.sessionId_, sessionId);
393 }