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
47 using namespace std::placeholders;
48 using namespace testing::ext;
49 using namespace OHOS::AppExecFwk;
50 using OHOS::iface_cast;
51 using OHOS::IRemoteObject;
52 using OHOS::sptr;
53 using testing::_;
54 using testing::Invoke;
55 using testing::Return;
56
57 namespace OHOS {
58 namespace AAFwk {
59 namespace {
60 const int32_t MOCK_MAIN_USER_ID = 100;
61
WaitUntilTaskFinished()62 static void WaitUntilTaskFinished()
63 {
64 const uint32_t maxRetryCount = 1000;
65 const uint32_t sleepTime = 1000;
66 uint32_t count = 0;
67 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
68 std::atomic<bool> taskCalled(false);
69 auto f = [&taskCalled]() { taskCalled.store(true); };
70 if (handler->SubmitTask(f)) {
71 while (!taskCalled.load()) {
72 ++count;
73 if (count >= maxRetryCount) {
74 break;
75 }
76 usleep(sleepTime);
77 }
78 }
79 }
80 } // namespace
81 class RunningInfosModuleTest : public testing::Test {
82 public:
83 static void SetUpTestCase(void);
84 static void TearDownTestCase(void);
85 void SetUp();
86 void TearDown();
87 void OnStartAms();
88 void OnStopAms();
89 Want CreateWant(const std::string& abilityName, const std::string& bundleName);
90
91 inline static std::shared_ptr<AbilityManagerService> abilityMgrServ_{ nullptr };
92 inline static MockAppMgrClient* mockAppMgrClient_ = nullptr;
93 };
94
CreateWant(const std::string & abilityName,const std::string & bundleName)95 Want RunningInfosModuleTest::CreateWant(const std::string& abilityName, const std::string& bundleName)
96 {
97 ElementName element;
98 element.SetDeviceID("device");
99 element.SetAbilityName(abilityName);
100 element.SetBundleName(bundleName);
101 Want want;
102 want.SetElement(element);
103 return want;
104 }
105
OnStartAms()106 void RunningInfosModuleTest::OnStartAms()
107 {
108 if (abilityMgrServ_) {
109 if (abilityMgrServ_->state_ == ServiceRunningState::STATE_RUNNING) {
110 return;
111 }
112
113 abilityMgrServ_->state_ = ServiceRunningState::STATE_RUNNING;
114
115 abilityMgrServ_->taskHandler_ = TaskHandlerWrap::CreateQueueHandler(AbilityConfig::NAME_ABILITY_MGR_SERVICE);
116 EXPECT_TRUE(abilityMgrServ_->taskHandler_);
117
118 // init user controller.
119 abilityMgrServ_->userController_ = std::make_shared<UserController>();
120 EXPECT_TRUE(abilityMgrServ_->userController_);
121 abilityMgrServ_->userController_->Init();
122 int userId = MOCK_MAIN_USER_ID;
123 abilityMgrServ_->userController_->SetCurrentUserId(userId);
124 abilityMgrServ_->InitConnectManager(userId, true);
125 abilityMgrServ_->InitDataAbilityManager(userId, true);
126 abilityMgrServ_->InitPendWantManager(userId, true);
127 abilityMgrServ_->systemDataAbilityManager_ = std::make_shared<DataAbilityManager>();
128 EXPECT_TRUE(abilityMgrServ_->systemDataAbilityManager_);
129
130 AmsConfigurationParameter::GetInstance().Parse();
131
132 abilityMgrServ_->interceptorExecuter_ = std::make_shared<AbilityInterceptorExecuter>();
133 EXPECT_TRUE(abilityMgrServ_->interceptorExecuter_);
134
135 abilityMgrServ_->InitMissionListManager(userId, true);
136 abilityMgrServ_->connectManager_->SetTaskHandler(abilityMgrServ_->taskHandler_);
137 auto topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked();
138 if (topAbility) {
139 topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
140 }
141 WaitUntilTaskFinished();
142 return;
143 }
144
145 GTEST_LOG_(INFO) << "OnStart fail";
146 }
147
OnStopAms()148 void RunningInfosModuleTest::OnStopAms()
149 {
150 abilityMgrServ_->taskHandler_.reset();
151 abilityMgrServ_->state_ = ServiceRunningState::STATE_NOT_START;
152 }
153
SetUpTestCase()154 void RunningInfosModuleTest::SetUpTestCase()
155 {
156 MockNativeToken::SetNativeToken();
157 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
158 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
159 auto appScheduler = DelayedSingleton<AppScheduler>::GetInstance();
160 mockAppMgrClient_ = new MockAppMgrClient();
161 if (mockAppMgrClient_) {
162 appScheduler->appMgrClient_.reset(mockAppMgrClient_);
163 GTEST_LOG_(INFO) << "mock appMgrClient_ ok";
164 }
165 }
166
TearDownTestCase()167 void RunningInfosModuleTest::TearDownTestCase()
168 {
169 delete mockAppMgrClient_;
170 mockAppMgrClient_ = nullptr;
171 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
172 }
173
SetUp()174 void RunningInfosModuleTest::SetUp()
175 {
176 abilityMgrServ_ = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
177 OnStartAms();
178 }
179
TearDown()180 void RunningInfosModuleTest::TearDown()
181 {
182 OnStopAms();
183 OHOS::DelayedSingleton<AbilityManagerService>::DestroyInstance();
184 }
185
186 /*
187 * Feature: AbilityManagerService
188 * Function: GetAbilityRunningInfos
189 * SubFunction: NA
190 * FunctionPoints:query ability running infos
191 * EnvConditions: NA
192 * CaseDescription: start page ability, mock object, call query function.
193 */
194 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_001, TestSize.Level1)
195 {
196 std::string abilityName = "MusicAbility";
197 std::string bundleName = "com.ix.hiMusic";
198 EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1);
199 Want want = CreateWant(abilityName, bundleName);
200
201 auto result = abilityMgrServ_->StartAbility(want);
202 EXPECT_EQ(OHOS::ERR_OK, result);
203 EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
204
205 std::vector<AbilityRunningInfo> infos;
206 abilityMgrServ_->GetAbilityRunningInfos(infos);
207 size_t infoCount{ 1 };
208 EXPECT_TRUE(infos.size() == infoCount);
209 if (infos.size() == infoCount) {
210 EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
211 EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
212 }
213 }
214
215 /*
216 * Feature: AbilityManagerService
217 * Function: GetAbilityRunningInfos
218 * SubFunction: NA
219 * FunctionPoints:query ability running infos
220 * EnvConditions: NA
221 * CaseDescription: start service ability, mock object, call query function.
222 */
223 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_002, TestSize.Level1)
224 {
225 std::string abilityName = "EnterAbility";
226 std::string bundleName = "com.ohos.camera";
227 EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1);
228 Want want = CreateWant(abilityName, bundleName);
229 auto result = abilityMgrServ_->StartAbility(want);
230 EXPECT_EQ(OHOS::ERR_OK, result);
231 EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
232
233 std::vector<AbilityRunningInfo> infos;
234 abilityMgrServ_->GetAbilityRunningInfos(infos);
235 size_t infoCount{ 1 };
236 EXPECT_TRUE(infos.size() == infoCount);
237 if (infos.size() == infoCount) {
238 EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
239 EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
240 }
241 }
242
243 /*
244 * Feature: AbilityManagerService
245 * Function: GetAbilityRunningInfos
246 * SubFunction: NA
247 * FunctionPoints:query ability running infos
248 * EnvConditions: NA
249 * CaseDescription: start launcher, mock object, call query function.
250 */
251 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_003, TestSize.Level1)
252 {
253 std::string abilityName = "com.ohos.launcher.MainAbility";
254 std::string bundleName = "com.ohos.launcher";
255 EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1);
256 Want want = CreateWant(abilityName, bundleName);
257 auto result = abilityMgrServ_->StartAbility(want);
258 EXPECT_EQ(OHOS::ERR_OK, result);
259 EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1);
260
261 std::vector<AbilityRunningInfo> infos;
262 abilityMgrServ_->GetAbilityRunningInfos(infos);
263 size_t infoCount{ 1 };
264 EXPECT_TRUE(infos.size() == infoCount);
265 if (infos.size() == infoCount) {
266 EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
267 EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
268 }
269 }
270
271 /*
272 * Feature: AbilityManagerService
273 * Function: GetAbilityRunningInfos
274 * SubFunction: NA
275 * FunctionPoints:query ability running infos
276 * EnvConditions: NA
277 * CaseDescription: start two page abilities, mock object, call query function.
278 */
279 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_004, TestSize.Level1)
280 {
281 std::string abilityName = "MusicAbility";
282 std::string bundleName = "com.ix.hiMusic";
283 EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2);
284 Want want = CreateWant(abilityName, bundleName);
285 auto result = abilityMgrServ_->StartAbility(want);
286 EXPECT_EQ(OHOS::ERR_OK, result);
287
288 auto topAbility = abilityMgrServ_->currentMissionListManager_->GetCurrentTopAbilityLocked();
289 EXPECT_TRUE(topAbility);
290 topAbility->SetAbilityState(AbilityState::FOREGROUND);
291
292 std::string abilityName2 = "MusicAbilityOther";
293 std::string bundleName2 = "com.ix.hiMusicOther";
294 want = CreateWant(abilityName2, bundleName2);
295 auto result2 = abilityMgrServ_->StartAbility(want);
296 EXPECT_EQ(OHOS::ERR_OK, result2);
297 EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2);
298
299 std::vector<AbilityRunningInfo> infos;
300 abilityMgrServ_->GetAbilityRunningInfos(infos);
301 size_t infoCount{ 2 };
302 EXPECT_TRUE(infos.size() == infoCount);
303 if (infos.size() == infoCount) {
304 EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName2);
305 EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
306 EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName);
307 EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::FOREGROUND));
308 }
309 }
310
311 /*
312 * Feature: AbilityManagerService
313 * Function: GetAbilityRunningInfos
314 * SubFunction: NA
315 * FunctionPoints:query ability running infos
316 * EnvConditions: NA
317 * CaseDescription: start two service abilities, mock object, call query function.
318 */
319 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_005, TestSize.Level1)
320 {
321 std::string abilityName = "EnterAbility";
322 std::string bundleName = "com.ohos.photos";
323 EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2);
324 Want want = CreateWant(abilityName, bundleName);
325 auto result = abilityMgrServ_->StartAbility(want);
326 EXPECT_EQ(OHOS::ERR_OK, result);
327
328 std::string abilityName2 = "EnterAbility";
329 std::string bundleName2 = "com.ohos.camera";
330 want = CreateWant(abilityName2, bundleName2);
331 auto result2 = abilityMgrServ_->StartAbility(want);
332 EXPECT_EQ(OHOS::ERR_OK, result2);
333 EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2);
334
335 std::vector<AbilityRunningInfo> infos;
336 abilityMgrServ_->GetAbilityRunningInfos(infos);
337 size_t infoCount{ 2 };
338 EXPECT_TRUE(infos.size() == infoCount);
339 if (infos.size() == infoCount) {
340 EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName);
341 EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
342 EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName2);
343 EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::INITIAL));
344 }
345 }
346
347 /*
348 * Feature: AbilityManagerService
349 * Function: GetAbilityRunningInfos
350 * SubFunction: NA
351 * FunctionPoints:query ability running infos
352 * EnvConditions: NA
353 * CaseDescription: start two launcher abilities, mock object, call query function.
354 */
355 HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_006, TestSize.Level1)
356 {
357 std::string abilityName = "com.ohos.launcher.MainAbility";
358 std::string bundleName = "com.ohos.launcher";
359 EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2);
360 Want want = CreateWant(abilityName, bundleName);
361 auto result = abilityMgrServ_->StartAbility(want);
362 EXPECT_EQ(OHOS::ERR_OK, result);
363
364 auto topAbility = abilityMgrServ_->currentMissionListManager_->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