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,
__anoncca5df980202(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,
__anoncca5df980302(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 sptr<CompletedDispatcher> completedData;
304 WantAgentHelper::TriggerWantAgent(wantAgent, callback, paramsInfo, completedData, nullptr);
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,
__anoncca5df980402(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 =
__anoncca5df980502(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 =
__anoncca5df980602(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,
__anoncca5df980702(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 =
__anoncca5df980802(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
__anoncca5df980902(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,
__anoncca5df980a02(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,
__anoncca5df980b02(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
__anoncca5df980c02(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