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 "implicit_start_processor.h"
21 #undef private
22 #undef protected
23 #include "ability_ecological_rule_mgr_service_param.h"
24 #include "parameters.h"
25
26 using namespace OHOS;
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace OHOS::AppExecFwk;
30 namespace {
31 constexpr const char* SUPPORT_ACTION_START_SELECTOR = "persist.sys.ability.support.action_start_selector";
32 const std::string PARAM_ABILITY_APPINFOS = "ohos.ability.params.appInfos";
33 const std::string OPEN_LINK_APP_LINKING_ONLY = "appLinkingOnly";
34 const int NFC_CALLER_UID = 1027;
35 }
36 namespace OHOS {
37 namespace AAFwk {
38
39 class ImplicitStartProcessorTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase(void)47 void ImplicitStartProcessorTest::SetUpTestCase(void)
48 {}
TearDownTestCase(void)49 void ImplicitStartProcessorTest::TearDownTestCase(void)
50 {}
SetUp()51 void ImplicitStartProcessorTest::SetUp()
52 {}
TearDown()53 void ImplicitStartProcessorTest::TearDown()
54 {}
55
56 /*
57 * Feature: ImplicitStartProcessor
58 * Function: ImplicitStartAbility
59 * SubFunction: NA
60 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbility
61 * EnvConditions: NA
62 * CaseDescription: Verify ImplicitStartAbility
63 */
64 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbility_001, TestSize.Level1)
65 {
66 auto processor = std::make_shared<ImplicitStartProcessor>();
67 AbilityRequest request;
68 int32_t userId = 0;
69 bool res = processor->ImplicitStartAbility(request, userId,
70 AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED, "", true);
71 EXPECT_TRUE(res);
72 }
73
74 /*
75 * Feature: ImplicitStartProcessor
76 * Function: CheckImplicitStartExtensionIsValid
77 * SubFunction: NA
78 * FunctionPoints:ImplicitStartProcessor CheckImplicitStartExtensionIsValid
79 * EnvConditions: NA
80 * CaseDescription: Verify CheckImplicitStartExtensionIsValid
81 */
82 HWTEST_F(ImplicitStartProcessorTest, CheckImplicitStartExtensionIsValid_001, TestSize.Level1)
83 {
84 auto processor = std::make_shared<ImplicitStartProcessor>();
85 AbilityRequest request;
86 ExtensionAbilityInfo extensionInfo;
87 Want want;
88 want.SetElementName("bundle", "");
89 request.want = want;
90 bool res = processor->CheckImplicitStartExtensionIsValid(request, extensionInfo);
91 EXPECT_TRUE(res);
92 }
93
94 /*
95 * Feature: ImplicitStartProcessor
96 * Function: CheckImplicitStartExtensionIsValid
97 * SubFunction: NA
98 * FunctionPoints:ImplicitStartProcessor CheckImplicitStartExtensionIsValid
99 * EnvConditions: NA
100 * CaseDescription: Verify CheckImplicitStartExtensionIsValid
101 */
102 HWTEST_F(ImplicitStartProcessorTest, CheckImplicitStartExtensionIsValid_002, TestSize.Level1)
103 {
104 auto processor = std::make_shared<ImplicitStartProcessor>();
105 AbilityRequest request;
106 ExtensionAbilityInfo extensionInfo;
107 Want want;
108 want.SetElementName("", "");
109 request.want = want;
110 extensionInfo.type = ExtensionAbilityType::WORK_SCHEDULER;
111 bool res = processor->CheckImplicitStartExtensionIsValid(request, extensionInfo);
112 EXPECT_FALSE(res);
113 }
114
115 /*
116 * Feature: ImplicitStartProcessor
117 * Function: CheckImplicitStartExtensionIsValid
118 * SubFunction: NA
119 * FunctionPoints:ImplicitStartProcessor CheckImplicitStartExtensionIsValid
120 * EnvConditions: NA
121 * CaseDescription: Verify CheckImplicitStartExtensionIsValid
122 */
123 HWTEST_F(ImplicitStartProcessorTest, CheckImplicitStartExtensionIsValid_003, TestSize.Level1)
124 {
125 auto processor = std::make_shared<ImplicitStartProcessor>();
126 AbilityRequest request;
127 ExtensionAbilityInfo extensionInfo;
128 Want want;
129 want.SetElementName("", "");
130 request.want = want;
131 extensionInfo.type = ExtensionAbilityType::FORM;
132 bool res = processor->CheckImplicitStartExtensionIsValid(request, extensionInfo);
133 EXPECT_TRUE(res);
134 }
135
136 /*
137 * Feature: ImplicitStartProcessor
138 * Function: ImplicitStartAbilityInner
139 * SubFunction: NA
140 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
141 * EnvConditions: NA
142 * CaseDescription: Verify ImplicitStartAbilityInner
143 */
144 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_001, TestSize.Level1)
145 {
146 auto processor = std::make_shared<ImplicitStartProcessor>();
147 Want want;
148 AbilityRequest request;
149 int32_t userId = 0;
150 request.callType = AbilityCallType::START_OPTIONS_TYPE;
151 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
152 EXPECT_NE(res, ERR_OK);
153 }
154
155 /*
156 * Feature: ImplicitStartProcessor
157 * Function: ImplicitStartAbilityInner
158 * SubFunction: NA
159 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
160 * EnvConditions: NA
161 * CaseDescription: Verify ImplicitStartAbilityInner
162 */
163 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_002, TestSize.Level1)
164 {
165 auto processor = std::make_shared<ImplicitStartProcessor>();
166 Want want;
167 AbilityRequest request;
168 int32_t userId = 0;
169 request.callType = AbilityCallType::START_SETTINGS_TYPE;
170 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
171 EXPECT_NE(res, ERR_OK);
172 }
173
174 /*
175 * Feature: ImplicitStartProcessor
176 * Function: ImplicitStartAbilityInner
177 * SubFunction: NA
178 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
179 * EnvConditions: NA
180 * CaseDescription: Verify ImplicitStartAbilityInner
181 */
182 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_003, TestSize.Level1)
183 {
184 auto processor = std::make_shared<ImplicitStartProcessor>();
185 Want want;
186 AbilityRequest request;
187 int32_t userId = 0;
188 request.callType = AbilityCallType::START_EXTENSION_TYPE;
189 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
190 EXPECT_NE(res, ERR_OK);
191 }
192
193 /*
194 * Feature: ImplicitStartProcessor
195 * Function: ImplicitStartAbilityInner
196 * SubFunction: NA
197 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
198 * EnvConditions: NA
199 * CaseDescription: Verify ImplicitStartAbilityInner
200 */
201 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_004, TestSize.Level1)
202 {
203 auto processor = std::make_shared<ImplicitStartProcessor>();
204 Want want;
205 AbilityRequest request;
206 int32_t userId = 0;
207 request.callType = AbilityCallType::CALL_REQUEST_TYPE;
208 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
209 EXPECT_NE(res, ERR_OK);
210 }
211
212 /*
213 * Feature: ImplicitStartProcessor
214 * Function: CallStartAbilityInner
215 * SubFunction: NA
216 * FunctionPoints:ImplicitStartProcessor CallStartAbilityInner
217 * EnvConditions: NA
218 * CaseDescription: Verify CallStartAbilityInner
219 */
220 HWTEST_F(ImplicitStartProcessorTest, CallStartAbilityInner_001, TestSize.Level1)
221 {
222 auto processor = std::make_shared<ImplicitStartProcessor>();
223 int32_t userId = 0;
224 Want want;
__anon17e9b1d70202() 225 ImplicitStartProcessor::StartAbilityClosure callBack = []() -> int32_t {
226 return 1;
227 };
228 AbilityCallType callType = AbilityCallType::INVALID_TYPE;
229 bool res = processor->CallStartAbilityInner(userId, want, callBack, callType);
230 EXPECT_NE(res, ERR_OK);
231 }
232
233 /*
234 * Feature: ImplicitStartProcessor
235 * Function: CallStartAbilityInner
236 * SubFunction: NA
237 * FunctionPoints:ImplicitStartProcessor CallStartAbilityInner
238 * EnvConditions: NA
239 * CaseDescription: Verify CallStartAbilityInner
240 */
241 HWTEST_F(ImplicitStartProcessorTest, CallStartAbilityInner_002, TestSize.Level1)
242 {
243 auto processor = std::make_shared<ImplicitStartProcessor>();
244 int32_t userId = 0;
245 Want want;
__anon17e9b1d70302() 246 ImplicitStartProcessor::StartAbilityClosure callBack = []() -> int32_t {
247 return 1;
248 };
249 AbilityCallType callType = AbilityCallType::CALL_REQUEST_TYPE;
250 bool res = processor->CallStartAbilityInner(userId, want, callBack, callType);
251 EXPECT_NE(res, ERR_OK);
252 }
253
254 /*
255 * Feature: ImplicitStartProcessor
256 * Function: CallStartAbilityInner
257 * SubFunction: NA
258 * FunctionPoints:ImplicitStartProcessor CallStartAbilityInner
259 * EnvConditions: NA
260 * CaseDescription: Verify CallStartAbilityInner
261 */
262 HWTEST_F(ImplicitStartProcessorTest, CallStartAbilityInner_003, TestSize.Level1)
263 {
264 auto processor = std::make_shared<ImplicitStartProcessor>();
265 int32_t userId = 0;
266 Want want;
__anon17e9b1d70402() 267 ImplicitStartProcessor::StartAbilityClosure callBack = []() -> int32_t {
268 return ERR_OK;
269 };
270 AbilityCallType callType = AbilityCallType::CALL_REQUEST_TYPE;
271 bool res = processor->CallStartAbilityInner(userId, want, callBack, callType);
272 EXPECT_EQ(res, ERR_OK);
273 }
274
275 /*
276 * Feature: ImplicitStartProcessor
277 * Function: SetTargetLinkInfo
278 * SubFunction: NA
279 * FunctionPoints:ImplicitStartProcessor SetTargetLinkInfo
280 * EnvConditions: NA
281 * CaseDescription: Verify SetTargetLinkInfo
282 */
283 HWTEST_F(ImplicitStartProcessorTest, SetTargetLinkInfo_001, TestSize.Level1)
284 {
285 auto processor = std::make_shared<ImplicitStartProcessor>();
286 std::vector<AppExecFwk::SkillUriForAbilityAndExtension> skillUri;
287 AppExecFwk::SkillUriForAbilityAndExtension uri;
288 uri.isMatch = true;
289 uri.scheme = "https";
290 skillUri.emplace_back(uri);
291 Want want;
292 want.SetParam("appLinkingOnly", true);
293 processor->SetTargetLinkInfo(skillUri, want);
294 int32_t targetLinkType = want.GetIntParam("send_to_erms_targetLinkType", 0);
295 EXPECT_EQ(targetLinkType, 1);
296 }
297
298 /*
299 * Feature: ImplicitStartProcessor
300 * Function: SetTargetLinkInfo
301 * SubFunction: NA
302 * FunctionPoints:ImplicitStartProcessor SetTargetLinkInfo
303 * EnvConditions: NA
304 * CaseDescription: Verify SetTargetLinkInfo
305 */
306 HWTEST_F(ImplicitStartProcessorTest, SetTargetLinkInfo_002, TestSize.Level1)
307 {
308 auto processor = std::make_shared<ImplicitStartProcessor>();
309 std::vector<AppExecFwk::SkillUriForAbilityAndExtension> skillUri;
310 AppExecFwk::SkillUriForAbilityAndExtension uri;
311 uri.isMatch = true;
312 uri.scheme = "https";
313 skillUri.emplace_back(uri);
314 Want want;
315 want.SetAction("ohos.want.action.viewData");
316 processor->SetTargetLinkInfo(skillUri, want);
317 int32_t targetLinkType = want.GetIntParam("send_to_erms_targetLinkType", 0);
318 EXPECT_EQ(targetLinkType, 3);
319 }
320
321 /*
322 * Feature: ImplicitStartProcessor
323 * Function: SetTargetLinkInfo
324 * SubFunction: NA
325 * FunctionPoints:ImplicitStartProcessor SetTargetLinkInfo
326 * EnvConditions: NA
327 * CaseDescription: Verify SetTargetLinkInfo
328 */
329 HWTEST_F(ImplicitStartProcessorTest, SetTargetLinkInfo_003, TestSize.Level1)
330 {
331 auto processor = std::make_shared<ImplicitStartProcessor>();
332 std::vector<AppExecFwk::SkillUriForAbilityAndExtension> skillUri;
333 AppExecFwk::SkillUriForAbilityAndExtension uri;
334 uri.isMatch = true;
335 uri.scheme = "https";
336 skillUri.emplace_back(uri);
337 Want want;
338 processor->SetTargetLinkInfo(skillUri, want);
339 int32_t targetLinkType = want.GetIntParam("send_to_erms_targetLinkType", 0);
340 EXPECT_EQ(targetLinkType, 2);
341 }
342
343 /*
344 * Feature: ImplicitStartProcessor
345 * Function: MatchTypeAndUri
346 * SubFunction: NA
347 * FunctionPoints:ImplicitStartProcessor MatchTypeAndUri
348 * EnvConditions: NA
349 * CaseDescription: Verify MatchTypeAndUri
350 */
351 HWTEST_F(ImplicitStartProcessorTest, MatchTypeAndUri_001, TestSize.Level1)
352 {
353 auto processor = std::make_shared<ImplicitStartProcessor>();
354 Want want;
355 processor->MatchTypeAndUri(want);
356 want.SetType("haha");
357 EXPECT_EQ("haha", processor->MatchTypeAndUri(want));
358 want.SetType("");
359 want.SetUri("http://wwwsocom");
360 EXPECT_EQ("", processor->MatchTypeAndUri(want));
361 want.SetUri("http://www.so.com");
362 processor->MatchTypeAndUri(want);
363 }
364
365 /*
366 * Feature: ImplicitStartProcessor
367 * Function: ProcessLinkType
368 * SubFunction: NA
369 * FunctionPoints:ImplicitStartProcessor ProcessLinkType
370 * EnvConditions: NA
371 * CaseDescription: Verify ProcessLinkType SetUriReservedFlag SetUriReservedBundle etc.
372 */
373 HWTEST_F(ImplicitStartProcessorTest, ProcessLinkType_001, TestSize.Level1)
374 {
375 auto processor = std::make_shared<ImplicitStartProcessor>();
376 std::vector<AppExecFwk::AbilityInfo> abilityInfos;
377 AbilityInfo abilityInfo;
378 abilityInfos.push_back(abilityInfo);
379 AbilityInfo abilityInfo2;
380 abilityInfo2.linkType = AppExecFwk::LinkType::APP_LINK;
381 abilityInfos.push_back(abilityInfo2);
382 EXPECT_TRUE(processor != nullptr);
383 }
384
385 /*
386 * Feature: ImplicitStartProcessor
387 * Function: OnlyKeepReserveApp
388 * SubFunction: NA
389 * FunctionPoints:ImplicitStartProcessor OnlyKeepReserveApp
390 * EnvConditions: NA
391 * CaseDescription: Verify OnlyKeepReserveApp etc.
392 */
393 HWTEST_F(ImplicitStartProcessorTest, OnlyKeepReserveApp_001, TestSize.Level1)
394 {
395 auto processor = std::make_shared<ImplicitStartProcessor>();
396 std::vector<AppExecFwk::AbilityInfo> abilityInfos;
397 std::vector<AppExecFwk::ExtensionAbilityInfo> extensionAbInfos;
398 AppExecFwk::ExtensionAbilityInfo extensionAbInfo;
399 extensionAbInfos.push_back(extensionAbInfo);
400 AppExecFwk::AbilityInfo abilityInfo;
401 abilityInfo.bundleName = "haha";
402 abilityInfos.push_back(abilityInfo);
403 AbilityRequest abilityRequest;
404 processor->OnlyKeepReserveApp(abilityInfos, extensionAbInfos, abilityRequest);
405 EXPECT_TRUE(processor != nullptr);
406 }
407
408 /*
409 * Feature: ImplicitStartProcessor
410 * Function: GetDefaultAppProxy
411 * SubFunction: NA
412 * FunctionPoints:ImplicitStartProcessor GetDefaultAppProxy
413 * EnvConditions: NA
414 * CaseDescription: Verify GetDefaultAppProxy etc.
415 */
416 HWTEST_F(ImplicitStartProcessorTest, GetDefaultAppProxy_001, TestSize.Level1)
417 {
418 auto processor = std::make_shared<ImplicitStartProcessor>();
419 auto result = processor->GetDefaultAppProxy();
420 EXPECT_EQ(result, nullptr);
421 }
422
423 /*
424 * Feature: ImplicitStartProcessor
425 * Function: FilterAbilityList
426 * SubFunction: NA
427 * FunctionPoints:ImplicitStartProcessor FilterAbilityList
428 * EnvConditions: NA
429 * CaseDescription: Verify FilterAbilityList etc.
430 */
431 HWTEST_F(ImplicitStartProcessorTest, FilterAbilityList_001, TestSize.Level1)
432 {
433 auto processor = std::make_shared<ImplicitStartProcessor>();
434 Want want;
435 std::vector<AppExecFwk::AbilityInfo> abilityInfos;
436 std::vector<AppExecFwk::ExtensionAbilityInfo> extensionAbInfos;
437 int32_t userId = 100;
438 auto result = processor->FilterAbilityList(want, abilityInfos, extensionAbInfos, userId);
439 EXPECT_EQ(result, true);
440 }
441
442 /*
443 * Feature: ImplicitStartProcessor
444 * Function: AddIdentity
445 * SubFunction: NA
446 * FunctionPoints:ImplicitStartProcessor AddIdentity
447 * EnvConditions: NA
448 * CaseDescription: Verify AddIdentity ResetCallingIdentityAsCaller AddAbilityInfoToDialogInfos etc.
449 */
450 HWTEST_F(ImplicitStartProcessorTest, AddIdentity_001, TestSize.Level1)
451 {
452 auto processor = std::make_shared<ImplicitStartProcessor>();
453 int32_t userId = 102;
454 std::string identity;
455 processor->AddIdentity(userId, identity);
456 processor->ResetCallingIdentityAsCaller(userId, true);
457 AddInfoParam param;
458 std::vector<DialogAppInfo> dialogAppInfos;
459 param.isExtension = true;
460 param.info.type = AbilityType::FORM;
461 processor->AddAbilityInfoToDialogInfos(param, dialogAppInfos);
462 param.isExtension = false;
463 processor->AddAbilityInfoToDialogInfos(param, dialogAppInfos);
464 EXPECT_TRUE(processor != nullptr);
465 }
466 } // namespace AAFwk
467 } // namespace OHOS
468