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 <thread>
17 #include <functional>
18 #include <fstream>
19 #include <nlohmann/json.hpp>
20 
21 #include <gtest/gtest.h>
22 #include <gmock/gmock.h>
23 
24 #define private public
25 #define protected public
26 #include "sa_mgr_client.h"
27 #include "mock_ability_connect_callback_stub.h"
28 #include "mock_ability_scheduler.h"
29 #include "mock_app_mgr_client.h"
30 #include "mock_bundle_mgr.h"
31 #include "mock_native_token.h"
32 #include "ability_state.h"
33 #include "ability_manager_errors.h"
34 #include "sa_mgr_client.h"
35 #include "system_ability_definition.h"
36 #include "ability_manager_service.h"
37 #include "ability_connect_callback_proxy.h"
38 #include "ability_config.h"
39 #include "pending_want_manager.h"
40 #include "pending_want_record.h"
41 #undef private
42 #undef protected
43 #include "wants_info.h"
44 #include "want_receiver_stub.h"
45 #include "want_sender_stub.h"
46 #include "mission_list_manager.h"
47 
48 using namespace std::placeholders;
49 using namespace testing::ext;
50 using namespace OHOS::AppExecFwk;
51 using OHOS::iface_cast;
52 using OHOS::IRemoteObject;
53 using OHOS::sptr;
54 using testing::_;
55 using testing::Invoke;
56 using testing::Return;
57 
58 namespace OHOS {
59 namespace AAFwk {
60 namespace {
61 const int32_t MOCK_MAIN_USER_ID = 100;
62 
WaitUntilTaskFinished()63 static void WaitUntilTaskFinished()
64 {
65     const uint32_t maxRetryCount = 1000;
66     const uint32_t sleepTime = 1000;
67     uint32_t count = 0;
68     auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
69     std::atomic<bool> taskCalled(false);
70     auto f = [&taskCalled]() { taskCalled.store(true); };
71     if (handler->SubmitTask(f)) {
72         while (!taskCalled.load()) {
73             ++count;
74             if (count >= maxRetryCount) {
75                 break;
76             }
77             usleep(sleepTime);
78         }
79     }
80 }
81 }  // namespace
82 class RunningInfosModuleTest : public testing::Test {
83 public:
84     static void SetUpTestCase(void);
85     static void TearDownTestCase(void);
86     void SetUp();
87     void TearDown();
88     void OnStartAms();
89     void OnStopAms();
90     Want CreateWant(const std::string& abilityName, const std::string& bundleName);
91 
92     inline static std::shared_ptr<AbilityManagerService> abilityMgrServ_{ nullptr };
93     inline static MockAppMgrClient* mockAppMgrClient_ = nullptr;
94 };
95 
CreateWant(const std::string & abilityName,const std::string & bundleName)96 Want RunningInfosModuleTest::CreateWant(const std::string& abilityName, const std::string& bundleName)
97 {
98     ElementName element;
99     element.SetDeviceID("device");
100     element.SetAbilityName(abilityName);
101     element.SetBundleName(bundleName);
102     Want want;
103     want.SetElement(element);
104     return want;
105 }
106 
OnStartAms()107 void RunningInfosModuleTest::OnStartAms()
108 {
109     if (abilityMgrServ_) {
110         if (abilityMgrServ_->state_ == ServiceRunningState::STATE_RUNNING) {
111             return;
112         }
113 
114         abilityMgrServ_->state_ = ServiceRunningState::STATE_RUNNING;
115 
116         abilityMgrServ_->taskHandler_ = TaskHandlerWrap::CreateQueueHandler(AbilityConfig::NAME_ABILITY_MGR_SERVICE);
117         EXPECT_TRUE(abilityMgrServ_->taskHandler_);
118 
119         // init user controller.
120         abilityMgrServ_->userController_ = std::make_shared<UserController>();
121         EXPECT_TRUE(abilityMgrServ_->userController_);
122         abilityMgrServ_->userController_->Init();
123         int userId = MOCK_MAIN_USER_ID;
124         abilityMgrServ_->userController_->SetCurrentUserId(userId);
125 
126         AmsConfigurationParameter::GetInstance().Parse();
127 
128         abilityMgrServ_->interceptorExecuter_ = std::make_shared<AbilityInterceptorExecuter>();
129         EXPECT_TRUE(abilityMgrServ_->interceptorExecuter_);
130 
131         abilityMgrServ_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
132         abilityMgrServ_->subManagersHelper_->InitSubManagers(userId, true);
133         abilityMgrServ_->subManagersHelper_->currentConnectManager_->SetTaskHandler(abilityMgrServ_->taskHandler_);
134         auto topAbility = reinterpret_cast<MissionListManager*>(abilityMgrServ_->
135             GetMissionListManagerByUserId(userId).get())->GetCurrentTopAbilityLocked();
136         if (topAbility) {
137             topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
138         }
139         WaitUntilTaskFinished();
140         return;
141     }
142 
143     GTEST_LOG_(INFO) << "OnStart fail";
144 }
145 
OnStopAms()146 void RunningInfosModuleTest::OnStopAms()
147 {
148     abilityMgrServ_->taskHandler_.reset();
149     abilityMgrServ_->state_ = ServiceRunningState::STATE_NOT_START;
150 }
151 
SetUpTestCase()152 void RunningInfosModuleTest::SetUpTestCase()
153 {
154     MockNativeToken::SetNativeToken();
155     OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
156         OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
157     auto appScheduler = DelayedSingleton<AppScheduler>::GetInstance();
158     mockAppMgrClient_ = new MockAppMgrClient();
159     if (mockAppMgrClient_) {
160         appScheduler->appMgrClient_.reset(mockAppMgrClient_);
161         GTEST_LOG_(INFO) << "mock appMgrClient_ ok";
162     }
163 }
164 
TearDownTestCase()165 void RunningInfosModuleTest::TearDownTestCase()
166 {
167     delete mockAppMgrClient_;
168     mockAppMgrClient_ = nullptr;
169     OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
170 }
171 
SetUp()172 void RunningInfosModuleTest::SetUp()
173 {
174     abilityMgrServ_ = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
175     OnStartAms();
176 }
177 
TearDown()178 void RunningInfosModuleTest::TearDown()
179 {
180     OnStopAms();
181     OHOS::DelayedSingleton<AbilityManagerService>::DestroyInstance();
182 }
183 
184 /*
185  * Feature: AbilityManagerService
186  * Function: GetAbilityRunningInfos
187  * SubFunction: NA
188  * FunctionPoints:query ability running infos
189  * EnvConditions: NA
190  * CaseDescription: start page ability, mock object, call query function.
191  */
192 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_001, TestSize.Level1)
193 {
194     std::string abilityName = "MusicAbility";
195     std::string bundleName = "com.ix.hiMusic";
196     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(1);
197     Want want = CreateWant(abilityName, bundleName);
198 
199     auto result = abilityMgrServ_->StartAbility(want);
200     EXPECT_EQ(OHOS::ERR_OK, result);
201     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
202 
203     std::vector<AbilityRunningInfo> infos;
204     abilityMgrServ_->GetAbilityRunningInfos(infos);
205     size_t infoCount{ 1 };
206     EXPECT_TRUE(infos.size() == infoCount);
207     if (infos.size() == infoCount) {
208         EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
209         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
210     }
211 }
212 
213 /*
214  * Feature: AbilityManagerService
215  * Function: GetAbilityRunningInfos
216  * SubFunction: NA
217  * FunctionPoints:query ability running infos
218  * EnvConditions: NA
219  * CaseDescription: start service ability, mock object, call query function.
220  */
221 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_002, TestSize.Level1)
222 {
223     std::string abilityName = "EnterAbility";
224     std::string bundleName = "com.ohos.camera";
225     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(1);
226     Want want = CreateWant(abilityName, bundleName);
227     auto result = abilityMgrServ_->StartAbility(want);
228     EXPECT_EQ(OHOS::ERR_OK, result);
229     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
230 
231     std::vector<AbilityRunningInfo> infos;
232     abilityMgrServ_->GetAbilityRunningInfos(infos);
233     size_t infoCount{ 1 };
234     EXPECT_TRUE(infos.size() == infoCount);
235     if (infos.size() == infoCount) {
236         EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
237         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
238     }
239 }
240 
241 /*
242  * Feature: AbilityManagerService
243  * Function: GetAbilityRunningInfos
244  * SubFunction: NA
245  * FunctionPoints:query ability running infos
246  * EnvConditions: NA
247  * CaseDescription: start launcher, mock object, call query function.
248  */
249 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_003, TestSize.Level1)
250 {
251     std::string abilityName = "com.ohos.launcher.MainAbility";
252     std::string bundleName = "com.ohos.launcher";
253     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(1);
254     Want want = CreateWant(abilityName, bundleName);
255     auto result = abilityMgrServ_->StartAbility(want);
256     EXPECT_EQ(OHOS::ERR_OK, result);
257     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
258 
259     std::vector<AbilityRunningInfo> infos;
260     abilityMgrServ_->GetAbilityRunningInfos(infos);
261     size_t infoCount{ 1 };
262     EXPECT_TRUE(infos.size() == infoCount);
263     if (infos.size() == infoCount) {
264         EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
265         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
266     }
267 }
268 
269 /*
270  * Feature: AbilityManagerService
271  * Function: GetAbilityRunningInfos
272  * SubFunction: NA
273  * FunctionPoints:query ability running infos
274  * EnvConditions: NA
275  * CaseDescription: start two page abilities, mock object, call query function.
276  */
277 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_004, TestSize.Level1)
278 {
279     std::string abilityName = "MusicAbility";
280     std::string bundleName = "com.ix.hiMusic";
281     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(2);
282     Want want = CreateWant(abilityName, bundleName);
283     auto result = abilityMgrServ_->StartAbility(want);
284     EXPECT_EQ(OHOS::ERR_OK, result);
285 
286     auto topAbility = reinterpret_cast<MissionListManager*>(abilityMgrServ_->subManagersHelper_->
287             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
288     EXPECT_TRUE(topAbility);
289     topAbility->SetAbilityState(AbilityState::FOREGROUND);
290 
291     std::string abilityName2 = "MusicAbilityOther";
292     std::string bundleName2 = "com.ix.hiMusicOther";
293     want = CreateWant(abilityName2, bundleName2);
294     auto result2 = abilityMgrServ_->StartAbility(want);
295     EXPECT_EQ(OHOS::ERR_OK, result2);
296     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2);
297 
298     std::vector<AbilityRunningInfo> infos;
299     abilityMgrServ_->GetAbilityRunningInfos(infos);
300     size_t infoCount{ 2 };
301     EXPECT_TRUE(infos.size() == infoCount);
302     if (infos.size() == infoCount) {
303         EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName2);
304         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
305         EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName);
306         EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::FOREGROUND));
307     }
308 }
309 
310 /*
311  * Feature: AbilityManagerService
312  * Function: GetAbilityRunningInfos
313  * SubFunction: NA
314  * FunctionPoints:query ability running infos
315  * EnvConditions: NA
316  * CaseDescription: start two service abilities, mock object, call query function.
317  */
318 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_005, TestSize.Level1)
319 {
320     std::string abilityName = "EnterAbility";
321     std::string bundleName = "com.ohos.photos";
322     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(2);
323     Want want = CreateWant(abilityName, bundleName);
324     auto result = abilityMgrServ_->StartAbility(want);
325     EXPECT_EQ(OHOS::ERR_OK, result);
326 
327     std::string abilityName2 = "EnterAbility";
328     std::string bundleName2 = "com.ohos.camera";
329     want = CreateWant(abilityName2, bundleName2);
330     auto result2 = abilityMgrServ_->StartAbility(want);
331     EXPECT_EQ(OHOS::ERR_OK, result2);
332     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2);
333 
334     std::vector<AbilityRunningInfo> infos;
335     abilityMgrServ_->GetAbilityRunningInfos(infos);
336     size_t infoCount{ 2 };
337     EXPECT_TRUE(infos.size() == infoCount);
338     if (infos.size() == infoCount) {
339         EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
340         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
341         EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName2);
342         EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::INITIAL));
343     }
344 }
345 
346 /*
347  * Feature: AbilityManagerService
348  * Function: GetAbilityRunningInfos
349  * SubFunction: NA
350  * FunctionPoints:query ability running infos
351  * EnvConditions: NA
352  * CaseDescription: start two launcher abilities, mock object, call query function.
353  */
354 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_006, TestSize.Level1)
355 {
356     std::string abilityName = "com.ohos.launcher.MainAbility";
357     std::string bundleName = "com.ohos.launcher";
358     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(2);
359     Want want = CreateWant(abilityName, bundleName);
360     auto result = abilityMgrServ_->StartAbility(want);
361     EXPECT_EQ(OHOS::ERR_OK, result);
362 
363     auto topAbility = reinterpret_cast<MissionListManager*>(abilityMgrServ_->subManagersHelper_->
364             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
365     EXPECT_TRUE(topAbility);
366     topAbility->SetAbilityState(AbilityState::FOREGROUND);
367 
368     std::string abilityName2 = "com.ohos.launcher.MainAbilityOther";
369     std::string bundleName2 = "com.ohos.launcherOther";
370     want = CreateWant(abilityName2, bundleName2);
371     auto result2 = abilityMgrServ_->StartAbility(want);
372     EXPECT_EQ(OHOS::ERR_OK, result2);
373     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2);
374 
375     std::vector<AbilityRunningInfo> infos;
376     abilityMgrServ_->GetAbilityRunningInfos(infos);
377     size_t infoCount{ 2 };
378     EXPECT_TRUE(infos.size() == infoCount);
379     if (infos.size() == infoCount) {
380         EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName2);
381         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
382         EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName);
383         EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::FOREGROUND));
384     }
385 }
386 
387 /*
388  * Feature: AbilityManagerService
389  * Function: GetExtensionRunningInfos
390  * SubFunction: NA
391  * FunctionPoints:query extension running infos
392  * EnvConditions: NA
393  * CaseDescription: start service ability, mock object, call query function.
394  */
395 HWTEST_F(RunningInfosModuleTest, GetExtensionRunningInfos_001, TestSize.Level1)
396 {
397     std::string abilityName = "hiExtension";
398     std::string bundleName = "com.ix.hiExtension";
399     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(1);
400     Want want = CreateWant(abilityName, bundleName);
401     auto result = abilityMgrServ_->StartAbility(want);
402     EXPECT_EQ(OHOS::ERR_OK, result);
403     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
404 
405     std::vector<ExtensionRunningInfo> infos;
406     int upperLimit = 10;
407     abilityMgrServ_->GetExtensionRunningInfos(upperLimit, infos);
408     size_t infoCount{ 1 };
409     EXPECT_TRUE(infos.size() == infoCount);
410     if (infos.size() == infoCount) {
411         EXPECT_TRUE(infos[0].extension.GetAbilityName() == abilityName);
412     }
413 }
414 
415 /*
416  * Feature: AbilityManagerService
417  * Function: GetExtensionRunningInfos
418  * SubFunction: NA
419  * FunctionPoints:query extension running infos
420  * EnvConditions: NA
421  * CaseDescription: start service abilities, mock object, call query function.
422  */
423 HWTEST_F(RunningInfosModuleTest, GetExtensionRunningInfos_002, TestSize.Level1)
424 {
425     std::string abilityName = "hiExtension";
426     std::string bundleName = "com.ix.hiExtension";
427     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(2);
428     Want want = CreateWant(abilityName, bundleName);
429     auto result = abilityMgrServ_->StartAbility(want);
430     EXPECT_EQ(OHOS::ERR_OK, result);
431 
432     std::string abilityName2 = "hiExtensionOther";
433     std::string bundleName2 = "com.ix.hiExtension";
434     want = CreateWant(abilityName2, bundleName2);
435     auto result2 = abilityMgrServ_->StartAbility(want);
436     EXPECT_EQ(OHOS::ERR_OK, result2);
437     EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2);
438 
439     std::vector<ExtensionRunningInfo> infos;
440     int upperLimit = 10;
441     abilityMgrServ_->GetExtensionRunningInfos(upperLimit, infos);
442     size_t infoCount{ 2 };
443     if (infos.size() == infoCount) {
444         EXPECT_TRUE(infos[0].extension.GetAbilityName() == abilityName);
445         EXPECT_TRUE(infos[1].extension.GetAbilityName() == abilityName2);
446     }
447 }
448 
449 /*
450  * Feature: AbilityManagerService
451  * Function: GetProcessRunningInfos
452  * SubFunction: NA
453  * FunctionPoints:query process running infos
454  * EnvConditions: NA
455  * CaseDescription: start service ability, mock object, call query function.
456  */
457 HWTEST_F(RunningInfosModuleTest, GetProcessRunningInfos_001, TestSize.Level1)
458 {
459     std::string abilityName = "hiExtension";
460     std::string bundleName = "com.ix.hiExtension";
461     EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _, _)).Times(1);
462     Want want = CreateWant(abilityName, bundleName);
463     auto result = abilityMgrServ_->StartAbility(want);
464     EXPECT_EQ(OHOS::ERR_OK, result);
465     EXPECT_CALL(*mockAppMgrClient_, GetAllRunningProcesses(_)).Times(1);
466 
467     std::vector<RunningProcessInfo> infos;
468     auto ret = abilityMgrServ_->GetProcessRunningInfos(infos);
469     EXPECT_EQ(OHOS::ERR_OK, ret);
470 }
471 }  // namespace AAFwk
472 }  // namespace OHOS
473