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 private public
22 #include "app_account_authenticator_session_manager.h"
23 #include "app_account_authenticator_session.h"
24 #include "app_account_authenticator_callback.h"
25 #include "app_account_constants.h"
26 #undef private
27 #include "iservice_registry.h"
28 #include "mock_app_account_authenticator_stub.h"
29 #include "system_ability_definition.h"
30 
31 using namespace testing;
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::AccountSA;
35 
36 namespace {
37 const std::string BUNDLE_NAME = "bundlename";
38 const std::string STRING_OWNER = "com.example.name";
39 const std::string ABILITY_NAME = "abilityName";
40 const std::string VALUE = "VALUE";
41 const std::string SESSION_ID = "sessionId";
42 const std::string SESSION_ID_OTHER = "sessionId1";
43 const int32_t SESSION_MAX_NUM = 256;
44 const int32_t UID = 1;
45 }  // namespace
46 
47 bool g_status = false;
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 MockSpecicalAuthenticatorCallback final : public AppAccountAuthenticatorCallbackStub {
56 public:
OnResult(int32_t resultCode,const AAFwk::Want & result)57     void OnResult(int32_t resultCode, const AAFwk::Want &result)
58     {
59         g_status = true;
60     }
OnRequestRedirected(AAFwk::Want & request)61     void OnRequestRedirected(AAFwk::Want &request)
62     {
63         g_status = true;
64     }
OnRequestContinued()65     void OnRequestContinued()
66     {
67         g_status = true;
68     }
69 };
70 
71 class AppAccountSessionManagerModuleTest : public testing::Test {
72 public:
73     static void SetUpTestCase(void);
74     static void TearDownTestCase(void);
75     void SetUp(void) override;
76     void TearDown(void) override;
77     AppAccountAuthenticatorSessionManager *appAccountAuthenticatorSessionManagerPtr_;
78 };
79 
SetUpTestCase(void)80 void AppAccountSessionManagerModuleTest::SetUpTestCase(void)
81 {}
82 
TearDownTestCase(void)83 void AppAccountSessionManagerModuleTest::TearDownTestCase(void)
84 {}
85 
SetUp(void)86 void AppAccountSessionManagerModuleTest::SetUp(void) __attribute__((no_sanitize("cfi")))
87 {
88     testing::UnitTest *test = testing::UnitTest::GetInstance();
89     ASSERT_NE(test, nullptr);
90     const testing::TestInfo *testinfo = test->current_test_info();
91     ASSERT_NE(testinfo, nullptr);
92     string testCaseName = string(testinfo->name());
93     ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
94 
95     appAccountAuthenticatorSessionManagerPtr_ = &AppAccountAuthenticatorSessionManager::GetInstance();
96 }
97 
TearDown(void)98 void AppAccountSessionManagerModuleTest::TearDown(void)
99 {
100     GTEST_LOG_(INFO) << "TearDownTestCase exit";
101     std::lock_guard<std::mutex> lock(appAccountAuthenticatorSessionManagerPtr_->mutex_);
102     appAccountAuthenticatorSessionManagerPtr_->sessionMap_.clear();
103     appAccountAuthenticatorSessionManagerPtr_->abilitySessions_.clear();
104 }
105 
106 /**
107  * @tc.name: AppAccountAuthenticateTest_IsAccountRemovable_0100
108  * @tc.desc: test session manager func IsAccountRemovable.
109  * @tc.type: FUNC
110  * @tc.require:
111  */
112 HWTEST_F(
113     AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_IsAccountRemovable_0100, TestSize.Level1)
114 {
115     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
116 
117     AuthenticatorSessionRequest request;
118     ErrCode result = appAccountAuthenticatorSessionManagerPtr_->IsAccountRemovable(request);
119     ASSERT_EQ(result, ERR_OK);
120 }
121 
122 /**
123  * @tc.name: AppAccountAuthenticateTest_SelectAccountsByOptions_0100
124  * @tc.desc: test session manager func SelectAccountsByOptions.
125  * @tc.type: FUNC
126  * @tc.require:
127  */
128 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnAbilityConnectDone_0100,
129     TestSize.Level1)
130 {
131     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
132 
133     AuthenticatorSessionRequest request;
134     std::vector<AppAccountInfo> accounts;
135     ErrCode result = appAccountAuthenticatorSessionManagerPtr_->SelectAccountsByOptions(accounts, request);
136     ASSERT_EQ(result, ERR_OK);
137 }
138 
139 /**
140  * @tc.name: AppAccountAuthenticateTest_SelectAccountsByOptions_0100
141  * @tc.desc: according IsAccountRemovable test func OnAbilityConnectDone remoteObject is not nullptr.
142  * @tc.type: FUNC
143  * @tc.require:
144  */
145 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_SelectAccountsByOptions_0100,
146     TestSize.Level1)
147 {
148     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
149 
150     AuthenticatorSessionRequest request;
151     request.owner = STRING_OWNER;
152     ErrCode result = appAccountAuthenticatorSessionManagerPtr_->IsAccountRemovable(request);
153     ASSERT_EQ(result, ERR_OK);
154 }
155 
156 /**
157  * @tc.name: AppAccountAuthenticateTest_OnAbilityStateChanged_0100
158  * @tc.desc: test session manager func OnAbilityStateChanged.
159  * @tc.type: FUNC
160  * @tc.require:
161  */
162 HWTEST_F(
163     AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnAbilityStateChanged_0100, TestSize.Level1)
164 {
165     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
166 
167     SessionAppStateObserver obServer;
168     AppExecFwk::AbilityStateData abilityStateData;
169     obServer.OnAbilityStateChanged(abilityStateData);
170 
171     abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_TERMINATED);
172     abilityStateData.abilityName = ABILITY_NAME;
173     abilityStateData.uid = UID;
174     std::string key = abilityStateData.abilityName + std::to_string(abilityStateData.uid);
175     auto size = appAccountAuthenticatorSessionManagerPtr_->abilitySessions_.size();
176     appAccountAuthenticatorSessionManagerPtr_->OnAbilityStateChanged(abilityStateData);
177     ASSERT_EQ(size, appAccountAuthenticatorSessionManagerPtr_->abilitySessions_.size());
178 
179     std::set<std::string> abilitySessionsValue;
180     abilitySessionsValue.insert(VALUE);
181     appAccountAuthenticatorSessionManagerPtr_->abilitySessions_[key] = abilitySessionsValue;
182     appAccountAuthenticatorSessionManagerPtr_->OnAbilityStateChanged(abilityStateData);
183     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->abilitySessions_.empty(), true);
184 
185     abilitySessionsValue.insert(VALUE);
186     appAccountAuthenticatorSessionManagerPtr_->abilitySessions_[key] = abilitySessionsValue;
187     AuthenticatorAction action;
188     AuthenticatorSessionRequest request;
189     auto sessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
190     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[VALUE] = sessionPtr;
191     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_->sessionMap_[VALUE], nullptr);
192     appAccountAuthenticatorSessionManagerPtr_->OnAbilityStateChanged(abilityStateData);
193     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->sessionMap_[VALUE], nullptr);
194     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->abilitySessions_.empty(), true);
195 }
196 
197 /**
198  * @tc.name: AppAccountAuthenticateTest_UnregisterApplicationStateObserver_0100
199  * @tc.desc: test session manager func UnregisterApplicationStateObserver.
200  * @tc.type: FUNC
201  * @tc.require:
202  */
203 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_UnregisterApplicationStateObserver_0100,
204     TestSize.Level1)
205 {
206     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
207 
208     sptr<ISystemAbilityManager> samgrClient = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
209     ASSERT_NE(samgrClient, nullptr);
210     appAccountAuthenticatorSessionManagerPtr_->iAppMgr_ =
211         iface_cast<AppExecFwk::IAppMgr>(samgrClient->GetSystemAbility(APP_MGR_SERVICE_ID));
212     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_->iAppMgr_, nullptr);
213     appAccountAuthenticatorSessionManagerPtr_->appStateObserver_ = new (std::nothrow) SessionAppStateObserver();
214     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_->appStateObserver_, nullptr);
215     appAccountAuthenticatorSessionManagerPtr_->UnregisterApplicationStateObserver();
216     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->iAppMgr_, nullptr);
217     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->appStateObserver_, nullptr);
218 }
219 
220 /**
221  * @tc.name: AppAccountAuthenticateTest_RegisterApplicationStateObserver_0100
222  * @tc.desc: test session manager func RegisterApplicationStateObserver.
223  * @tc.type: FUNC
224  * @tc.require:
225  */
226 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_RegisterApplicationStateObserver_0100,
227     TestSize.Level1)
228 {
229     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
230 
231     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->appStateObserver_, nullptr);
232     appAccountAuthenticatorSessionManagerPtr_->RegisterApplicationStateObserver();
233     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_->appStateObserver_, nullptr);
234 }
235 
236 /**
237  * @tc.name: AppAccountAuthenticateTest_OpenSession_0100
238  * @tc.desc: test session manager func OpenSession.
239  * @tc.type: FUNC
240  * @tc.require:
241  */
242 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OpenSession_0100, TestSize.Level1)
243 {
244     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
245 
246     std::shared_ptr<AppAccountAuthenticatorSession> session = nullptr;
247     ErrCode result = appAccountAuthenticatorSessionManagerPtr_->OpenSession(session);
248     ASSERT_EQ(ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION, result);
249 
250     for (int i = 0; i < SESSION_MAX_NUM; i++) {
251         std::string key = std::to_string(i);
252         AuthenticatorAction action;
253         AuthenticatorSessionRequest request;
254         auto sessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
255         ASSERT_NE(sessionPtr, nullptr);
256         appAccountAuthenticatorSessionManagerPtr_->sessionMap_[key] = sessionPtr;
257     }
258     ASSERT_EQ(appAccountAuthenticatorSessionManagerPtr_->sessionMap_.size(), SESSION_MAX_NUM);
259     AuthenticatorAction action;
260     AuthenticatorSessionRequest request;
261     session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
262     ASSERT_NE(session, nullptr);
263     result = appAccountAuthenticatorSessionManagerPtr_->OpenSession(session);
264     ASSERT_EQ(ERR_APPACCOUNT_SERVICE_OAUTH_BUSY, result);
265 }
266 
267 /**
268  * @tc.name: AppAccountAuthenticateTest_OpenSession_0200
269  * @tc.desc: test session manager func OpenSession abnormal branch.
270  * @tc.type: FUNC
271  * @tc.require:
272  */
273 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OpenSession_0200, TestSize.Level1)
274 {
275     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
276 
277     std::string key = std::to_string(SESSION_MAX_NUM);
278     AuthenticatorAction action;
279     AuthenticatorSessionRequest request;
280     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
281     ASSERT_NE(session, nullptr);
282     appAccountAuthenticatorSessionManagerPtr_->sessionMap_.clear();
283     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[key] = session;
284 
285     ErrCode result = appAccountAuthenticatorSessionManagerPtr_->OpenSession(session);
286     ASSERT_EQ(ERR_OK, result);
287     appAccountAuthenticatorSessionManagerPtr_->CloseSession(key);
288     auto size = appAccountAuthenticatorSessionManagerPtr_->sessionMap_.size();
289     appAccountAuthenticatorSessionManagerPtr_->CloseSession(key);
290     ASSERT_EQ(size, appAccountAuthenticatorSessionManagerPtr_->sessionMap_.size());
291 }
292 
293 /**
294  * @tc.name: AppAccountAuthenticateTest_GetSession_0100
295  * @tc.desc: test session manager func GetSession normal branch.
296  * @tc.type: FUNC
297  * @tc.require:
298  */
299 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_GetSession_0100, TestSize.Level1)
300 {
301     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
302 
303     std::string sessionId = SESSION_ID;
304     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
305     ASSERT_EQ(sessionPtr, nullptr);
306 
307     AuthenticatorAction action;
308     AuthenticatorSessionRequest request;
309     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
310     ASSERT_NE(session, nullptr);
311     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
312     sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
313     ASSERT_NE(sessionPtr, nullptr);
314 }
315 
316 /**
317  * @tc.name: AppAccountAuthenticateTest_GetAuthenticatorCallback_0100
318  * @tc.desc: test session manager func GetAuthenticatorCallback abnormal branch.
319  * @tc.type: FUNC
320  * @tc.require:
321  */
322 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_GetAuthenticatorCallback_0200,
323     TestSize.Level1)
324 {
325     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
326 
327     AuthenticatorSessionRequest request;
328     request.sessionId = SESSION_ID;
329     sptr<IRemoteObject> callback = nullptr;
330     ErrCode sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetAuthenticatorCallback(request, callback);
331     ASSERT_EQ(sessionPtr, ERR_APPACCOUNT_SERVICE_OAUTH_SESSION_NOT_EXIST);
332 
333     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[SESSION_ID] = nullptr;
334     sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetAuthenticatorCallback(request, callback);
335     ASSERT_EQ(sessionPtr, ERR_APPACCOUNT_SERVICE_OAUTH_SESSION_NOT_EXIST);
336 }
337 
338 /**
339  * @tc.name: AppAccountAuthenticateTest_OnSessionServerDied_0100
340  * @tc.desc: test session manager func OnSessionServerDied.
341  * @tc.type: FUNC
342  * @tc.require:
343  */
344 HWTEST_F(
345     AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionServerDied_0100, TestSize.Level1)
346 {
347     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
348 
349     std::string sessionId = SESSION_ID;
350     AuthenticatorAction action;
351     AuthenticatorSessionRequest request;
352     auto testCallBack = new (std::nothrow) MockAuthenticatorCallback();
353     ASSERT_NE(testCallBack, nullptr);
354     request.callback = testCallBack;
355     ASSERT_NE(request.callback, nullptr);
356     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
357     ASSERT_NE(session, nullptr);
358 
359     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
360     ASSERT_EQ(sessionPtr, nullptr);
361     EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(0));
362     appAccountAuthenticatorSessionManagerPtr_->OnSessionServerDied(sessionId);
363 
364     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
365     sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
366     ASSERT_EQ(sessionPtr, session);
367     EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(1));
368     appAccountAuthenticatorSessionManagerPtr_->OnSessionServerDied(sessionId);
369 }
370 
371 /**
372  * @tc.name: AppAccountAuthenticateTest_RegisterApplicationStateObserver_0200
373  * @tc.desc: test session manager func RegisterApplicationStateObserver appStateObserver is exist.
374  * @tc.type: FUNC
375  * @tc.require:
376  */
377 HWTEST_F(
378     AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionServerDied_0200, TestSize.Level1)
379 {
380     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
381 
382     appAccountAuthenticatorSessionManagerPtr_->appStateObserver_ = new (std::nothrow) SessionAppStateObserver();
383     appAccountAuthenticatorSessionManagerPtr_->RegisterApplicationStateObserver();
384     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_->appStateObserver_, nullptr);
385 }
386 
387 /**
388  * @tc.name: AppAccountAuthenticateTest_OnSessionAbilityConnectDone_0100
389  * @tc.desc: test session manager func OnSessionAbilityConnectDone.
390  * @tc.type: FUNC
391  * @tc.require:
392  */
393 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionAbilityConnectDone_0100,
394     TestSize.Level1)
395 {
396     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
397 
398     std::string sessionId = SESSION_ID;
399     AppExecFwk::ElementName element;
400     sptr<IRemoteObject> remoteObject = nullptr;
401     int32_t resultCode = -1;
402     AuthenticatorAction action;
403     AuthenticatorSessionRequest request;
404     auto testCallBack = new (std::nothrow) MockAuthenticatorCallback();
405     ASSERT_NE(testCallBack, nullptr);
406     request.callback = testCallBack;
407     ASSERT_NE(request.callback, nullptr);
408     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
409     ASSERT_NE(session, nullptr);
410 
411     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
412     ASSERT_EQ(sessionPtr, nullptr);
413     EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(0));
414     appAccountAuthenticatorSessionManagerPtr_->OnSessionAbilityConnectDone(
415         sessionId, element, remoteObject, resultCode);
416 }
417 
418 /**
419  * @tc.name: AppAccountAuthenticateTest_OnSessionAbilityDisconnectDone_0100
420  * @tc.desc: test session manager func OnSessionAbilityDisconnectDone.
421  * @tc.type: FUNC
422  * @tc.require:
423  */
424 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionAbilityDisconnectDone_0100,
425     TestSize.Level1)
426 {
427     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
428 
429     std::string sessionId = SESSION_ID;
430     AppExecFwk::ElementName element;
431     int32_t resultCode = -1;
432     AuthenticatorAction action;
433     AuthenticatorSessionRequest request;
434     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
435     ASSERT_NE(session, nullptr);
436     session->isConnected_ = true;
437 
438     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
439     ASSERT_EQ(sessionPtr, nullptr);
440     appAccountAuthenticatorSessionManagerPtr_->OnSessionAbilityDisconnectDone(sessionId, element, resultCode);
441     ASSERT_EQ(session->isConnected_, true);
442 
443     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
444     sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
445     ASSERT_EQ(sessionPtr, session);
446     appAccountAuthenticatorSessionManagerPtr_->OnSessionAbilityDisconnectDone(sessionId, element, resultCode);
447     ASSERT_EQ(session->isConnected_, false);
448 }
449 
450 /**
451  * @tc.name: AppAccountAuthenticateTest_OnSessionRequestRedirected_0100
452  * @tc.desc: test session manager func OnSessionRequestRedirected OnSessionResult OnSessionRequestContinued.
453  * @tc.type: FUNC
454  * @tc.require:
455  */
456 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionRequestRedirected_0100,
457     TestSize.Level1)
458 {
459     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
460 
461     std::string sessionId = SESSION_ID;
462     AAFwk::Want result;
463     int32_t resultCode = -1;
464     AuthenticatorAction action;
465     AuthenticatorSessionRequest request;
466     request.owner = BUNDLE_NAME;
467     auto testCallBack = new (std::nothrow) MockAuthenticatorCallback();
468     ASSERT_NE(testCallBack, nullptr);
469     request.callback = testCallBack;
470     ASSERT_NE(request.callback, nullptr);
471     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
472     ASSERT_NE(session, nullptr);
473 
474     EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(0));
475     appAccountAuthenticatorSessionManagerPtr_->OnSessionResult(sessionId, resultCode, result);
476 
477     EXPECT_CALL(*testCallBack, OnRequestContinued()).Times(Exactly(0));
478     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestContinued(sessionId);
479 
480     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
481     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
482     ASSERT_EQ(sessionPtr, session);
483 
484     EXPECT_CALL(*testCallBack, OnRequestContinued()).Times(Exactly(1));
485     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestContinued(sessionId);
486 
487     EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(1));
488     appAccountAuthenticatorSessionManagerPtr_->OnSessionResult(sessionId, resultCode, result);
489 
490     EXPECT_CALL(*testCallBack, OnResult(_, _)).Times(Exactly(1));
491     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestRedirected(sessionId, result);
492 
493     AppExecFwk::ElementName element = result.GetElement();
494     element.SetBundleName(BUNDLE_NAME);
495     ASSERT_EQ(element.GetBundleName(), request.owner);
496     result.SetElement(element);
497     EXPECT_CALL(*testCallBack, OnRequestRedirected(_)).Times(Exactly(1));
498     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestRedirected(sessionId, result);
499 }
500 
501 /**
502  * @tc.name: AppAccountAuthenticateTest_OnSessionRequestRedirected_0200
503  * @tc.desc: test session manager func OnSessionRequestRedirected callback is nullptr branch.
504  * @tc.type: FUNC
505  * @tc.require:
506  */
507 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionRequestRedirected_0200,
508     TestSize.Level1)
509 {
510     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
511 
512     std::string sessionId = SESSION_ID;
513     AAFwk::Want result;
514     AuthenticatorAction action;
515     AuthenticatorSessionRequest request;
516     request.owner = BUNDLE_NAME;
517     auto testCallBack = new (std::nothrow) MockSpecicalAuthenticatorCallback();
518     ASSERT_NE(testCallBack, nullptr);
519     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
520     ASSERT_NE(session, nullptr);
521 
522     AppExecFwk::ElementName element = result.GetElement();
523     element.SetBundleName(BUNDLE_NAME);
524     ASSERT_EQ(element.GetBundleName(), request.owner);
525     result.SetElement(element);
526     session->isConnected_ = true;
527     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
528     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
529     ASSERT_EQ(sessionPtr, session);
530     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestRedirected(sessionId, result);
531     ASSERT_EQ(g_status, false);
532 }
533 
534 /**
535  * @tc.name: AppAccountAuthenticateTest_OnSessionRequestRedirected_0300
536  * @tc.desc: test session manager func OnSessionRequestRedirected action is AUTHENTICATE or ADD_ACCOUNT_IMPLICITLY.
537  * @tc.type: FUNC
538  * @tc.require:
539  */
540 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionRequestRedirected_0300,
541     TestSize.Level1)
542 {
543     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
544 
545     std::string sessionId = SESSION_ID;
546     AAFwk::Want result;
547     AuthenticatorSessionRequest request;
548     request.owner = BUNDLE_NAME;
549     auto testCallBack = new (std::nothrow) MockAuthenticatorCallback();
550     ASSERT_NE(testCallBack, nullptr);
551     request.callback = testCallBack;
552     ASSERT_NE(request.callback, nullptr);
553     auto session = std::make_shared<AppAccountAuthenticatorSession>(AUTHENTICATE, request);
554     ASSERT_NE(session, nullptr);
555 
556     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
557     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
558     ASSERT_EQ(sessionPtr, session);
559     AppExecFwk::ElementName element = result.GetElement();
560     element.SetBundleName(BUNDLE_NAME);
561     ASSERT_EQ(element.GetBundleName(), request.owner);
562     result.SetElement(element);
563     EXPECT_CALL(*testCallBack, OnRequestRedirected(_)).Times(Exactly(1));
564     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestRedirected(sessionId, result);
565 
566     AuthenticatorSessionRequest request1;
567     request1.owner = BUNDLE_NAME;
568     auto session1 = std::make_shared<AppAccountAuthenticatorSession>(ADD_ACCOUNT_IMPLICITLY, request1);
569     ASSERT_NE(session, nullptr);
570 
571     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[SESSION_ID_OTHER] = session1;
572     auto sessionPtr1 = appAccountAuthenticatorSessionManagerPtr_->GetSession(SESSION_ID_OTHER);
573     ASSERT_EQ(sessionPtr1, session1);
574     AppExecFwk::ElementName element1 = result.GetElement();
575     element1.SetBundleName(BUNDLE_NAME);
576     ASSERT_EQ(element1.GetBundleName(), request1.owner);
577     result.SetElement(element1);
578     request1.callback = testCallBack;
579     ASSERT_NE(request1.callback, nullptr);
580     EXPECT_CALL(*testCallBack, OnRequestRedirected(_)).Times(Exactly(1));
581     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestRedirected(sessionId, result);
582 }
583 
584 /**
585  * @tc.name: AppAccountAuthenticateTest_OnSessionRequestRedirected_0400
586  * @tc.desc: test session manager func OnSessionRequestRedirected sessionid is invalid.
587  * @tc.type: FUNC
588  * @tc.require:
589  */
590 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionRequestRedirected_0400,
591     TestSize.Level1)
592 {
593     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
594     AAFwk::Want result;
595     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestRedirected(SESSION_ID, result);
596     auto session = appAccountAuthenticatorSessionManagerPtr_->GetSession(SESSION_ID);
597     ASSERT_EQ(session, nullptr);
598 }
599 
600 /**
601  * @tc.name: AppAccountAuthenticateTest_OnSessionRequestContinued_0200
602  * @tc.desc: test session manager func OnSessionRequestContinued callback is nullptr isconnected is true.
603  * @tc.type: FUNC
604  * @tc.require:
605  */
606 HWTEST_F(AppAccountSessionManagerModuleTest, AppAccountSessionManagerModuleTest_OnSessionRequestContinued_0200,
607     TestSize.Level1)
608 {
609     ASSERT_NE(appAccountAuthenticatorSessionManagerPtr_, nullptr);
610 
611     std::string sessionId = SESSION_ID;
612     AAFwk::Want result;
613     AuthenticatorAction action;
614     AuthenticatorSessionRequest request;
615     auto testCallBack = new (std::nothrow) MockSpecicalAuthenticatorCallback();
616     ASSERT_NE(testCallBack, nullptr);
617 
618     auto session = std::make_shared<AppAccountAuthenticatorSession>(action, request);
619     session->isConnected_ = true;
620     ASSERT_NE(session, nullptr);
621     appAccountAuthenticatorSessionManagerPtr_->sessionMap_[sessionId] = session;
622     auto sessionPtr = appAccountAuthenticatorSessionManagerPtr_->GetSession(sessionId);
623     ASSERT_EQ(sessionPtr, session);
624     appAccountAuthenticatorSessionManagerPtr_->OnSessionRequestContinued(sessionId);
625     ASSERT_EQ(g_status, false);
626 }