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