1 /*
2 * Copyright (c) 2021-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
18 #define private public
19 #define protected public
20 #include "sa_mgr_client.h"
21 #include "pending_want_manager.h"
22 #include "app_scheduler.h"
23 #include "ability_manager_service.h"
24 #include "want_agent_helper.h"
25 #include "ability_manager_client.h"
26 #undef private
27 #undef protected
28
29 #include "context/context.h"
30 #include "system_ability_definition.h"
31 #include "mock_ability_scheduler.h"
32 #include "mock_app_mgr_client.h"
33 #include "pending_want.h"
34 #include "mock_want_receiver.h"
35 #include "mock_bundle_mgr.h"
36 #include "ability_context.h"
37 #include "mock_compled_callback.h"
38 #include "mock_ability_mgr_service.h"
39 #include "os_account_manager.h"
40
41 using namespace OHOS::AbilityRuntime::WantAgent;
42 using namespace OHOS::AppExecFwk;
43
44 using namespace testing;
45 using testing::_;
46 using testing::Invoke;
47 using testing::Return;
48 using namespace testing::ext;
49
50 namespace OHOS {
51 namespace AAFwk {
52 namespace {
53 static const int FLAG_ONE_SHOT = 1 << 30;
54 int abilityRequestCode = 1;
55 int abilitiesRequestCode = 2;
56 int serviceRequestCode = 3;
57 int foregroundServicesRequestCode = 4;
58 int commonEventRequestCode = 4;
59 } // namespace
60 class PandingWantManagerTest : public testing::Test {
61 public:
62 static void SetUpTestCase(void);
63 static void TearDownTestCase(void);
64 void SetUp();
65 void TearDown();
66 WantSenderInfo GetAbility();
67 WantSenderInfo GetAbilities();
68 WantSenderInfo GetService();
69 WantSenderInfo GetForegroundService();
70 WantSenderInfo GetCommonEvent();
71 std::shared_ptr<AAFwk::Want> GetWant(std::string abilityName, std::string bundleName);
72 WantAgentInfo MakeWantAgentInfo(WantAgentConstant::OperationType &type, int requestCode,
73 std::vector<WantAgentConstant::Flags> &flags, std::vector<std::shared_ptr<AAFwk::Want>> wants);
74
75 public:
76 MockWantReceiver *receiver = new MockWantReceiver();
77 inline static MockAppMgrClient *appClient = nullptr;
78 inline static std::shared_ptr<AbilityManagerService> abilityManager = nullptr;
79 MockAbilityMgrService *amsSerice = new MockAbilityMgrService();
80 };
81
SetUpTestCase(void)82 void PandingWantManagerTest::SetUpTestCase(void)
83 {
84 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
85 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
86 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new (std::nothrow) BundleMgrService());
87
88 abilityManager = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
89 abilityManager->OnStart();
90
91 auto appScheduler = DelayedSingleton<AppScheduler>::GetInstance();
92 appClient = new MockAppMgrClient();
93 if (appClient) {
94 appScheduler->appMgrClient_.reset(appClient);
95 GTEST_LOG_(INFO) << "mock appMgrClient_ ok";
96 }
97 }
98
TearDownTestCase(void)99 void PandingWantManagerTest::TearDownTestCase(void)
100 {
101 abilityManager->OnStop();
102 if (appClient) {
103 delete appClient;
104 appClient = nullptr;
105 }
106 }
107
SetUp()108 void PandingWantManagerTest::SetUp()
109 {
110 if (amsSerice == nullptr) {
111 amsSerice = new MockAbilityMgrService();
112 }
113 AbilityManagerClient::GetInstance();
114 AbilityManagerClient::GetInstance()->proxy_ = amsSerice;
115 }
116
TearDown()117 void PandingWantManagerTest::TearDown()
118 {}
119
GetWant(std::string abilityName,std::string bundleName)120 std::shared_ptr<AAFwk::Want> PandingWantManagerTest::GetWant(std::string abilityName, std::string bundleName)
121 {
122 if (abilityName == "") {
123 abilityName = "hiMusic";
124 }
125 if (bundleName == "") {
126 bundleName = "com.ix.hiMusic";
127 }
128
129 ElementName element;
130 element.SetDeviceID("devices");
131 element.SetAbilityName(abilityName);
132 element.SetBundleName(bundleName);
133 Want want;
134 want.SetElement(element);
135 return std::make_shared<Want>(want);
136 }
137
GetAbility()138 WantSenderInfo PandingWantManagerTest::GetAbility()
139 {
140 int32_t flags = FLAG_ONE_SHOT;
141 WantsInfo wantsInfo;
142 wantsInfo.want = *(GetWant("hiMusic", "com.ix.hiMusic"));
143 wantsInfo.resolvedTypes = wantsInfo.want.GetType();
144
145 WantSenderInfo wantSenderInfo;
146 wantSenderInfo.type = (int32_t)WantAgentConstant::OperationType::START_ABILITY;
147 wantSenderInfo.allWants.push_back(wantsInfo);
148 wantSenderInfo.bundleName = "ix.com.hiMusic";
149 wantSenderInfo.flags = flags;
150 wantSenderInfo.userId = 0;
151 wantSenderInfo.requestCode = abilityRequestCode;
152 wantSenderInfo.resultWho = "GetAbility";
153 GTEST_LOG_(INFO) << "GetAbility";
154 return wantSenderInfo;
155 }
156
GetAbilities()157 WantSenderInfo PandingWantManagerTest::GetAbilities()
158 {
159 int32_t flags = (int32_t)FLAG_ONE_SHOT;
160
161 WantsInfo wantsInfo;
162 wantsInfo.want = *(GetWant("hiMusic", "com.ix.hiMusic"));
163 wantsInfo.resolvedTypes = wantsInfo.want.GetType();
164
165 WantsInfo wantsInfo2;
166 wantsInfo2.want = *(GetWant("hiRadio", "com.ix.hiRadio"));
167 wantsInfo2.resolvedTypes = wantsInfo2.want.GetType();
168
169 WantSenderInfo wantSenderInfo;
170 wantSenderInfo.type = (int32_t)WantAgentConstant::OperationType::START_ABILITIES;
171 wantSenderInfo.bundleName = "ix.com.hiRadio";
172 wantSenderInfo.flags = flags;
173 wantSenderInfo.userId = 0;
174 wantSenderInfo.requestCode = abilitiesRequestCode;
175 wantSenderInfo.resultWho = "GetAbilities";
176 wantSenderInfo.allWants.push_back(wantsInfo);
177 wantSenderInfo.allWants.push_back(wantsInfo2);
178 GTEST_LOG_(INFO) << "GetAbilities";
179 return wantSenderInfo;
180 }
181
GetService()182 WantSenderInfo PandingWantManagerTest::GetService()
183 {
184 int32_t flags = FLAG_ONE_SHOT;
185
186 WantsInfo wantsInfo;
187 wantsInfo.want = *(GetWant("hiService", "com.ix.hiService"));
188 wantsInfo.resolvedTypes = wantsInfo.want.GetType();
189
190 WantSenderInfo wantSenderInfo;
191 wantSenderInfo.type = (int32_t)WantAgentConstant::OperationType::START_SERVICE;
192 wantSenderInfo.allWants.push_back(wantsInfo);
193 wantSenderInfo.bundleName = "com.ix.hiService";
194 wantSenderInfo.flags = flags;
195 wantSenderInfo.userId = 0;
196 wantSenderInfo.requestCode = serviceRequestCode;
197 wantSenderInfo.resultWho = "GetService";
198 GTEST_LOG_(INFO) << "GetService";
199 return wantSenderInfo;
200 }
201
GetForegroundService()202 WantSenderInfo PandingWantManagerTest::GetForegroundService()
203 {
204 int32_t flags = FLAG_ONE_SHOT;
205
206 WantsInfo wantsInfo;
207 wantsInfo.want = *(GetWant("hiService", "com.ix.hiService"));
208 wantsInfo.resolvedTypes = wantsInfo.want.GetType();
209
210 WantSenderInfo wantSenderInfo;
211 wantSenderInfo.type = (int32_t)WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
212 wantSenderInfo.allWants.push_back(wantsInfo);
213 wantSenderInfo.bundleName = "ix.com.hiworld";
214 wantSenderInfo.flags = flags;
215 wantSenderInfo.userId = 0;
216 wantSenderInfo.requestCode = foregroundServicesRequestCode;
217 GTEST_LOG_(INFO) << "GetForegroundService";
218 return wantSenderInfo;
219 }
220
GetCommonEvent()221 WantSenderInfo PandingWantManagerTest::GetCommonEvent()
222 {
223 int32_t flags = FLAG_ONE_SHOT;
224
225 WantsInfo wantsInfo;
226 wantsInfo.want = *(GetWant("hiMusic", "com.ix.hiMusic"));
227 wantsInfo.resolvedTypes = wantsInfo.want.GetType();
228
229 WantSenderInfo wantSenderInfo;
230 wantSenderInfo.type = (int32_t)WantAgentConstant::OperationType::SEND_COMMON_EVENT;
231 wantSenderInfo.allWants.push_back(wantsInfo);
232 wantSenderInfo.bundleName = "ix.com.hiworld";
233 wantSenderInfo.flags = flags;
234 wantSenderInfo.userId = 0;
235 wantSenderInfo.requestCode = commonEventRequestCode;
236 GTEST_LOG_(INFO) << "GetCommonEvent";
237 return wantSenderInfo;
238 }
239
MakeWantAgentInfo(WantAgentConstant::OperationType & type,int requestCode,std::vector<WantAgentConstant::Flags> & flags,std::vector<std::shared_ptr<AAFwk::Want>> wants)240 WantAgentInfo PandingWantManagerTest::MakeWantAgentInfo(WantAgentConstant::OperationType &type, int requestCode,
241 std::vector<WantAgentConstant::Flags> &flags, std::vector<std::shared_ptr<AAFwk::Want>> wants)
242 {
243 WantAgentInfo info;
244 info.operationType_ = type;
245 info.requestCode_ = requestCode;
246 info.flags_ = flags;
247 info.wants_ = wants;
248 info.extraInfo_ = nullptr;
249 return info;
250 }
251
252 /*
253 * Feature: AaFwk
254 * Function: GetWantSender
255 * SubFunction: get foreground service ability
256 * FunctionPoints: NA
257 * EnvConditions: NA
258 * CaseDescription: get want sender / send want sender
259 */
260 HWTEST_F(PandingWantManagerTest, pending_want_mgr_test_005, TestSize.Level1)
261 {
262 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::SEND_COMMON_EVENT;
263 int requsetCode = 112;
264 WantAgentConstant::Flags flag = WantAgentConstant::Flags::ONE_TIME_FLAG;
265 std::vector<WantAgentConstant::Flags> flags;
266 flags.push_back(flag);
267
268 auto abilityWant = GetWant("hiRedio", "com.ix.hiRedio");
269 std::vector<std::shared_ptr<AAFwk::Want>> wants;
270 wants.push_back(abilityWant);
271
272 WantAgentInfo info = MakeWantAgentInfo(type, requsetCode, flags, wants);
273 std::shared_ptr<AbilityRuntime::Context> context = OHOS::AbilityRuntime::Context::GetApplicationContext();
274
275 // proxy start
276 auto amsProxyGetWantSenderReturn = [&abilityManager](const WantSenderInfo &wantSenderInfo,
__anon404a90770202(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken) 277 const sptr<IRemoteObject> &callerToken) {
278 EXPECT_EQ(wantSenderInfo.type, (int32_t)WantAgentConstant::OperationType::SEND_COMMON_EVENT);
279 return abilityManager->GetWantSender(wantSenderInfo, callerToken);
280 };
281 EXPECT_CALL(*amsSerice, GetWantSender(_, _)).Times(1).WillOnce(Invoke(amsProxyGetWantSenderReturn));
282
283 auto amsProxySendWantSenderReturn = [&abilityManager](const sptr<IWantSender> &target,
__anon404a90770302(const sptr<IWantSender> &target, const SenderInfo &senderInfo) 284 const SenderInfo &senderInfo) {
285 return abilityManager->SendWantSender(target, senderInfo);
286 };
287 EXPECT_CALL(*amsSerice, SendWantSender(_, _)).Times(1).WillOnce(Invoke(amsProxySendWantSenderReturn));
288 EXPECT_CALL(*amsSerice, GetPendingWantType(_)).Times(1).WillOnce(Return(0));
289
290 // proxy end
291 // call GetWantAgent
292 std::shared_ptr<WantAgent> wantAgent = WantAgentHelper::GetWantAgent(context, info);
293 EXPECT_NE(wantAgent, nullptr);
294 auto pandingWant = wantAgent->GetPendingWant();
295 EXPECT_NE(pandingWant, nullptr);
296
297 std::shared_ptr<CompletedCallback> callback;
298 MockCompletedCallback *call = new MockCompletedCallback();
299 callback.reset(call);
300
301 TriggerInfo paramsInfo("", nullptr, abilityWant, 11);
302
303 EXPECT_CALL(*call, OnSendFinished(_, _, _, _)).Times(1);
304 WantAgentHelper::TriggerWantAgent(wantAgent, callback, paramsInfo);
305 }
306
307 /*
308 * Feature: AaFwk
309 * Function: GetWantSender
310 * SubFunction: get ability info
311 * FunctionPoints: NA
312 * EnvConditions: NA
313 * CaseDescription: get want sender / send want sender
314 */
315 HWTEST_F(PandingWantManagerTest, pending_want_mgr_test_006, TestSize.Level1)
316 {
317 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_ABILITY;
318 int requsetCode = 18;
319 WantAgentConstant::Flags flag = WantAgentConstant::Flags::UPDATE_PRESENT_FLAG;
320 std::vector<WantAgentConstant::Flags> flags;
321 flags.push_back(flag);
322
323 auto abilityWant = GetWant("hiMusic", "com.ix.hiMusic");
324 std::vector<std::shared_ptr<AAFwk::Want>> wants;
325 wants.push_back(abilityWant);
326
327 WantAgentInfo info = MakeWantAgentInfo(type, requsetCode, flags, wants);
328 std::shared_ptr<AbilityRuntime::Context> context = OHOS::AbilityRuntime::Context::GetApplicationContext();
329
330 // proxy start
331 auto amsProxyGetWantSenderReturn = [&abilityManager](const WantSenderInfo &wantSenderInfo,
__anon404a90770402(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken) 332 const sptr<IRemoteObject> &callerToken) {
333 EXPECT_EQ(wantSenderInfo.type, (int32_t)WantAgentConstant::OperationType::START_ABILITY);
334 return abilityManager->GetWantSender(wantSenderInfo, callerToken);
335 };
336 EXPECT_CALL(*amsSerice, GetWantSender(_, _)).Times(1).WillOnce(Invoke(amsProxyGetWantSenderReturn));
337
338 auto amsProxyGetPendingWantType =
__anon404a90770502(const sptr<IWantSender> &target) 339 [&abilityManager](const sptr<IWantSender> &target) { return abilityManager->GetPendingWantType(target); };
340 EXPECT_CALL(*amsSerice, GetPendingWantType(_)).Times(1).WillOnce(Invoke(amsProxyGetPendingWantType));
341
342 auto amsProxyGetPendingWantCode =
__anon404a90770602(const sptr<IWantSender> &target) 343 [&abilityManager](const sptr<IWantSender> &target) { return abilityManager->GetPendingWantCode(target); };
344 EXPECT_CALL(*amsSerice, GetPendingWantCode(_)).Times(1).WillOnce(Invoke(amsProxyGetPendingWantCode));
345
346 auto amsProxyRegisterCancelListener = [&abilityManager](const sptr<IWantSender> &sender,
__anon404a90770702(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &recevier) 347 const sptr<IWantReceiver> &recevier) {
348 return abilityManager->RegisterCancelListener(sender, recevier);
349 };
350 EXPECT_CALL(*amsSerice, RegisterCancelListener(_, _)).Times(1).WillOnce(Invoke(amsProxyRegisterCancelListener));
351
352 auto amsProxyCancelWantSender =
__anon404a90770802(const sptr<IWantSender> &sender) 353 [&abilityManager](const sptr<IWantSender> &sender) { return abilityManager->CancelWantSender(sender); };
354 EXPECT_CALL(*amsSerice, CancelWantSender(_)).Times(1).WillOnce(Invoke(amsProxyCancelWantSender));
355 // proxy end
356
357 // call GetWantAgent
358 std::shared_ptr<WantAgent> wantAgent = WantAgentHelper::GetWantAgent(context, info);
359 EXPECT_NE(wantAgent, nullptr);
360 auto pandingWant = wantAgent->GetPendingWant();
361 EXPECT_NE(pandingWant, nullptr);
362
363 auto getType = WantAgentHelper::GetType(wantAgent);
364 EXPECT_EQ(getType, WantAgentConstant::OperationType::START_ABILITY);
365
366 int code = WantAgentHelper::GetHashCode(wantAgent);
367 EXPECT_NE(code, -1);
368
369 // mock CancelListener
__anon404a90770902(int resultCode) 370 auto cancalCall = [requsetCode](int resultCode) -> void { EXPECT_EQ(resultCode, requsetCode); };
371
372 std::shared_ptr<MockCancelListener> listener = std::make_shared<MockCancelListener>();
373 EXPECT_CALL(*listener, OnCancelled(_)).Times(1).WillOnce(Invoke(cancalCall));
374 WantAgentHelper::RegisterCancelListener(listener, wantAgent);
375 WantAgentHelper::Cancel(wantAgent);
376 }
377
378 /*
379 * Feature: AaFwk
380 * Function: GetWantSender
381 * SubFunction: start a page ability
382 * FunctionPoints: NA
383 * EnvConditions: NA
384 * CaseDescription: get want sender different flag effects
385 */
386 HWTEST_F(PandingWantManagerTest, pending_want_mgr_test_007, TestSize.Level1)
387 {
388 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_ABILITY;
389 int requsetCode = 21;
390 WantAgentConstant::Flags flag = WantAgentConstant::Flags::NO_BUILD_FLAG;
391 std::vector<WantAgentConstant::Flags> flags;
392 flags.push_back(flag);
393
394 auto abilityWant = GetWant("Netease music", "com.ix.hiMusic");
395 std::vector<std::shared_ptr<AAFwk::Want>> wants;
396 wants.push_back(abilityWant);
397
398 WantAgentInfo info = MakeWantAgentInfo(type, requsetCode, flags, wants);
399 std::shared_ptr<AbilityRuntime::Context> context = OHOS::AbilityRuntime::Context::GetApplicationContext();
400
401 // proxy start
402 auto amsProxyGetWantSenderReturn = [&abilityManager](const WantSenderInfo &wantSenderInfo,
__anon404a90770a02(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken) 403 const sptr<IRemoteObject> &callerToken) {
404 EXPECT_EQ(wantSenderInfo.type, (int32_t)WantAgentConstant::OperationType::START_ABILITY);
405 return abilityManager->GetWantSender(wantSenderInfo, callerToken);
406 };
407 EXPECT_CALL(*amsSerice, GetWantSender(_, _))
408 .Times(4)
409 .WillOnce(Invoke(amsProxyGetWantSenderReturn))
410 .WillOnce(Invoke(amsProxyGetWantSenderReturn))
411 .WillOnce(Invoke(amsProxyGetWantSenderReturn))
412 .WillOnce(Invoke(amsProxyGetWantSenderReturn));
413
414 auto amsProxyRegisterCancelListener = [&abilityManager](const sptr<IWantSender> &sender,
__anon404a90770b02(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &recevier) 415 const sptr<IWantReceiver> &recevier) {
416 return abilityManager->RegisterCancelListener(sender, recevier);
417 };
418 EXPECT_CALL(*amsSerice, RegisterCancelListener(_, _)).Times(1).WillOnce(Invoke(amsProxyRegisterCancelListener));
419 // proxy end
420
421 // call GetWantAgent
422 std::shared_ptr<WantAgent> wantAgent = WantAgentHelper::GetWantAgent(context, info);
423 // must be nullptr
424 EXPECT_EQ(wantAgent->GetPendingWant()->GetTarget(), nullptr);
425
426 WantAgentConstant::Flags flag1 = WantAgentConstant::Flags::ONE_TIME_FLAG;
427 flags.clear();
428 flags.push_back(flag1);
429 info = MakeWantAgentInfo(type, requsetCode, flags, wants);
430
431 std::shared_ptr<WantAgent> wantAgent1 = WantAgentHelper::GetWantAgent(context, info);
432 EXPECT_NE(wantAgent1->GetPendingWant()->GetTarget(), nullptr);
433 auto pandingWant1 = wantAgent1->GetPendingWant();
434 EXPECT_NE(pandingWant1, nullptr);
435
436 // update
437 WantAgentConstant::Flags flag2 = WantAgentConstant::Flags::UPDATE_PRESENT_FLAG;
438 flags.clear();
439 flags.push_back(flag2);
440
441 requsetCode = 24;
442 abilityWant = GetWant("redio", "com.ix.hiRedio");
443 wants.clear();
444 wants.push_back(abilityWant);
445 info = MakeWantAgentInfo(type, requsetCode, flags, wants);
446
447 std::shared_ptr<WantAgent> wantAgent2 = WantAgentHelper::GetWantAgent(context, info);
448 EXPECT_NE(wantAgent2->GetPendingWant()->GetTarget(), nullptr);
449 auto pandingWant2 = wantAgent2->GetPendingWant();
450 EXPECT_NE(pandingWant2, nullptr);
451
452 auto target = pandingWant2->GetTarget();
453 EXPECT_NE(target, nullptr);
454 sptr<PendingWantRecord> targetRecord = iface_cast<PendingWantRecord>(target->AsObject());
455
456 auto requestWant = targetRecord->GetKey()->GetRequestWant();
457 EXPECT_EQ(requestWant.GetElement().GetAbilityName(), "redio");
458 EXPECT_EQ(requestWant.GetElement().GetBundleName(), "com.ix.hiRedio");
459
460 // cancal
461 WantAgentConstant::Flags flag3 = WantAgentConstant::Flags::CANCEL_PRESENT_FLAG;
462 flags.clear();
463 flags.push_back(flag3);
464
465 info = MakeWantAgentInfo(type, requsetCode, flags, wants);
466
467 // mock CancelListener
__anon404a90770c02(int resultCode) 468 auto cancalCall = [requsetCode](int resultCode) -> void { EXPECT_EQ(resultCode, requsetCode); };
469
470 std::shared_ptr<MockCancelListener> listener = std::make_shared<MockCancelListener>();
471 EXPECT_CALL(*listener, OnCancelled(_)).Times(1).WillOnce(Invoke(cancalCall));
472 WantAgentHelper::RegisterCancelListener(listener, wantAgent2);
473
474 std::shared_ptr<WantAgent> wantAgent3 = WantAgentHelper::GetWantAgent(context, info);
475 EXPECT_EQ(wantAgent3->GetPendingWant()->GetTarget(), nullptr);
476 }
477 } // namespace AAFwk
478 } // namespace OHOS
479