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 #define private public
18 #define protected public
19 #include "ability_event_handler.h"
20 #include "ability_manager_service.h"
21 #undef private
22 #undef protected
23 
24 #include "ability_manager_errors.h"
25 #include "if_system_ability_manager.h"
26 #include "iservice_registry.h"
27 #include "mock_ability_connect_callback.h"
28 #include "mock_bundle_mgr.h"
29 #include "sa_mgr_client.h"
30 #include "system_ability_definition.h"
31 #include "ui_service_mgr_client_mock.h"
32 #include "mission_list_manager.h"
33 
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS::AppExecFwk;
37 namespace {
38 const std::string EVENT_MULT_APP_CHOOSE = "EVENT_MULT_APP_CHOOSE";
39 const std::string EVENT_MULT_APP_CLOSE = "EVENT_MULT_APP_CLOSE";
40 const std::string EVENT_TIPS_APP = "EVENT_TIPS_APP";
41 const std::string ACTION_VIEW = "ohos.want.action.viewData";
42 const std::string WANT_TYPE = "image/png";
43 const int32_t MOCK_MAIN_USER_ID = 100;
44 }
45 namespace OHOS {
46 namespace AAFwk {
WaitUntilTaskFinished()47 static void WaitUntilTaskFinished()
48 {
49     const uint32_t maxRetryCount = 1000;
50     const uint32_t sleepTime = 1000;
51     uint32_t count = 0;
52     auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
53     std::atomic<bool> taskCalled(false);
54     auto f = [&taskCalled]() { taskCalled.store(true); };
55     if (handler->SubmitTask(f)) {
56         while (!taskCalled.load()) {
57             ++count;
58             if (count >= maxRetryCount) {
59                 break;
60             }
61             usleep(sleepTime);
62         }
63     }
64 }
65 
66 class StartAbilityImplicitModuleTest : public testing::Test {
67 public:
68     static void TearDownTestCase();
69     void SetUp();
70     void TearDown();
71     void OnStartAms() const;
72     void OnStopAms() const;
73     static constexpr int TEST_WAIT_TIME = 100000;
74 
75 public:
76     AbilityRequest abilityRequest_;
77     std::shared_ptr<AbilityRecord> abilityRecord_{ nullptr };
78     std::shared_ptr<AbilityManagerService> abilityMs_ = DelayedSingleton<AbilityManagerService>::GetInstance();
79 };
80 
OnStartAms() const81 void StartAbilityImplicitModuleTest::OnStartAms() const
82 {
83     if (abilityMs_) {
84         if (abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) {
85             return;
86         }
87 
88         abilityMs_->state_ = ServiceRunningState::STATE_RUNNING;
89         abilityMs_->taskHandler_ = TaskHandlerWrap::CreateQueueHandler("StartAbilityImplicitModuleTest");
90         // init user controller.
91         abilityMs_->userController_ = std::make_shared<UserController>();
92         EXPECT_TRUE(abilityMs_->userController_);
93         abilityMs_->userController_->Init();
94         abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
95         abilityMs_->subManagersHelper_->InitSubManagers(MOCK_MAIN_USER_ID, true);
96 
97         AmsConfigurationParameter::GetInstance().Parse();
98         abilityMs_->iBundleManager_ = new BundleMgrService();
99         EXPECT_TRUE(abilityMs_->iBundleManager_);
100 
101         abilityMs_->implicitStartProcessor_ = std::make_shared<ImplicitStartProcessor>();
102         EXPECT_TRUE(abilityMs_->implicitStartProcessor_);
103         abilityMs_->implicitStartProcessor_->iBundleManager_ = new BundleMgrService();
104         EXPECT_TRUE(abilityMs_->implicitStartProcessor_->iBundleManager_);
105 
106         DelayedSingleton<SystemDialogScheduler>::GetInstance()->SetDeviceType("phone");
107         abilityMs_->SwitchManagers(0, false);
108         abilityMs_->userController_->SetCurrentUserId(MOCK_MAIN_USER_ID);
109         return;
110     }
111 
112     GTEST_LOG_(INFO) << "OnStart fail";
113 }
114 
OnStopAms() const115 void StartAbilityImplicitModuleTest::OnStopAms() const
116 {
117     abilityMs_->subManagersHelper_->currentMissionListManager_.reset();
118     abilityMs_->OnStop();
119 }
120 
TearDownTestCase()121 void StartAbilityImplicitModuleTest::TearDownTestCase()
122 {
123     OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
124 }
125 
SetUp()126 void StartAbilityImplicitModuleTest::SetUp()
127 {
128     OnStartAms();
129     WaitUntilTaskFinished();
130 }
131 
TearDown()132 void StartAbilityImplicitModuleTest::TearDown()
133 {
134     OnStopAms();
135 }
136 
137 /*
138  * Feature: StartAbilityImplicitModuleTest
139  * Function: StartAbility
140  * SubFunction: NA
141  * FunctionPoints: start ability by action
142  * EnvConditions: NA
143  * CaseDescription: start ability by action and type successful
144  */
145 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_001, TestSize.Level1)
146 {
147     EXPECT_TRUE(abilityMs_ != nullptr);
148 
149     Want want;
150     want.SetAction(ACTION_VIEW);
151     want.SetType(WANT_TYPE);
152     want.SetParam("numMock", 3);
153 
154     Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
155     abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
156     auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
157     auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
158 
159     EXPECT_TRUE(!params.empty());
160     EXPECT_TRUE(isCallBack);
161 
162     auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
163             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
164     EXPECT_TRUE(abilityRecord != nullptr);
165 
166     GTEST_LOG_(INFO) << "ability:" << abilityRecord->GetAbilityInfo().name;
167     GTEST_LOG_(INFO) << "bundle:" << abilityRecord->GetAbilityInfo().bundleName;
168 }
169 
170 /*
171  * Feature: StartAbilityImplicitModuleTest
172  * Function: StartAbility
173  * SubFunction: NA
174  * FunctionPoints: start ability by action
175  * EnvConditions: NA
176  * CaseDescription: start ability by action and type successful
177  */
178 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_002, TestSize.Level1)
179 {
180     EXPECT_TRUE(abilityMs_ != nullptr);
181 
182     Want want;
183     want.SetAction(ACTION_VIEW);
184     want.SetType(WANT_TYPE);
185     want.SetParam("numMock", 3);
186 
187     Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CLOSE);
188     abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
189     auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
190     auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
191 
192     EXPECT_TRUE(!params.empty());
193     EXPECT_TRUE(isCallBack);
194 
195     auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
196             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
197     EXPECT_TRUE(abilityRecord == nullptr);
198 }
199 
200 /*
201  * Feature: StartAbilityImplicitModuleTest
202  * Function: StartAbility
203  * SubFunction: NA
204  * FunctionPoints: start ability by action
205  * EnvConditions: NA
206  * CaseDescription: start ability by action and type successful
207  */
208 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_003, TestSize.Level1)
209 {
210     EXPECT_TRUE(abilityMs_ != nullptr);
211 
212     Want want;
213     want.SetAction(ACTION_VIEW);
214     want.SetType(WANT_TYPE);
215     want.SetParam("numMock", 1);
216 
217     Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
218     abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
219     auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
220     auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
221 
222     EXPECT_TRUE(params.empty());
223     EXPECT_TRUE(!isCallBack);
224 
225     auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
226             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
227     EXPECT_TRUE(abilityRecord != nullptr);
228 }
229 
230 /*
231  * Feature: StartAbilityImplicitModuleTest
232  * Function: StartAbility
233  * SubFunction: NA
234  * FunctionPoints: start ability by action
235  * EnvConditions: NA
236  * CaseDescription: start ability by action and type successful
237  */
238 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_004, TestSize.Level1)
239 {
240     EXPECT_TRUE(abilityMs_ != nullptr);
241 
242     Want want;
243     want.SetAction(ACTION_VIEW);
244     want.SetType(WANT_TYPE);
245     want.SetParam("numMock", 0);
246 
247     Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_TIPS_APP);
248     abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
249     auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
250     auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
251 
252     EXPECT_TRUE(!params.empty());
253     EXPECT_TRUE(isCallBack);
254 
255     auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
256             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
257     EXPECT_TRUE(abilityRecord == nullptr);
258 }
259 
260 /*
261  * Feature: StartAbilityImplicitModuleTest
262  * Function: StartAbility
263  * SubFunction: NA
264  * FunctionPoints: start ability by action
265  * EnvConditions: NA
266  * CaseDescription: start ability by action and type successful
267  */
268 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_005, TestSize.Level1)
269 {
270     EXPECT_TRUE(abilityMs_ != nullptr);
271 
272     Want want;
273     want.SetAction(ACTION_VIEW);
274     want.SetParam("numMock", 3);
275 
276     Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
277     auto ret = abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
278 
279     EXPECT_EQ(ret, ERR_OK);
280 }
281 }
282 }