1 /*
2 * Copyright (c) 2025 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 #include "ability_manager_service.h"
19 #include "task_handler_wrap.h"
20 #include "ability_record.h"
21 #include "sa_mgr_client.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::AAFwk;
25
26 namespace OHOS {
27 namespace AppExecFwk {
28 namespace {
29 const int BUNDLE_MGR_SERVICE_SYS_ABILITY_ID = 401;
30 }
31 class FreeInstallTest : public testing::Test {
32 public:
FreeInstallTest()33 FreeInstallTest()
34 {}
~FreeInstallTest()35 ~FreeInstallTest()
36 {}
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 sptr<Token> MockToken();
42 std::shared_ptr<FreeInstallManager> freeInstallManager_ = nullptr;
43 };
44
SetUpTestCase(void)45 void FreeInstallTest::SetUpTestCase(void) {}
46
TearDownTestCase(void)47 void FreeInstallTest::TearDownTestCase(void) {}
48
SetUp(void)49 void FreeInstallTest::SetUp(void) {}
50
TearDown(void)51 void FreeInstallTest::TearDown(void)
52 {}
53
MockToken()54 sptr<Token> FreeInstallTest::MockToken()
55 {
56 sptr<Token> token = nullptr;
57 AbilityRequest abilityRequest;
58 abilityRequest.appInfo.bundleName = "com.test.demo";
59 abilityRequest.abilityInfo.name = "MainAbility";
60 abilityRequest.abilityInfo.type = AbilityType::PAGE;
61 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
62 if (!abilityRecord) {
63 return nullptr;
64 }
65 return abilityRecord->GetToken();
66 }
67
68 /**
69 * @tc.number: RemoteFreeInstall_001
70 * @tc.name: RemoteFreeInstall
71 * @tc.desc: Test RemoteFreeInstall.
72 */
73 HWTEST_F(FreeInstallTest, FreeInstall_RemoteFreeInstall_001, TestSize.Level1)
74 {
75 auto abilityMs_ = std::make_shared<AbilityManagerService>();
76 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
77 Want want;
78 ElementName element("", "com.test.demo", "MainAbility");
79 want.SetElement(element);
80 const int32_t userId = 100;
81 const int requestCode = 0;
82 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
83 // mock callerToken
84 const sptr<IRemoteObject> callerToken = MockToken();
85 int res = 0;
86
87 usleep(100000); // 100000 means us.
88 // from freeInstallManager_->freeInstallList_ find startInstallTime
89 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
90 std::string bundleName = (*it).want.GetElement().GetBundleName();
91 std::string abilityName = (*it).want.GetElement().GetAbilityName();
92 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
93 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
94 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
95 break;
96 }
97 }
98 res = freeInstallManager_->RemoteFreeInstall(want, userId, requestCode, callerToken);
99 EXPECT_EQ(res, NOT_TOP_ABILITY);
100 }
101
102 /**
103 * @tc.number: RemoteFreeInstall_002
104 * @tc.name: RemoteFreeInstall
105 * @tc.desc: Test RemoteFreeInstall.
106 */
107 HWTEST_F(FreeInstallTest, FreeInstall_RemoteFreeInstall_002, TestSize.Level1)
108 {
109 auto abilityMs_ = std::make_shared<AbilityManagerService>();
110 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
111 Want want;
112 ElementName element("", "com.test.demo", "MainAbility");
113 want.SetElement(element);
114 const int32_t userId = 100;
115 const int requestCode = 0;
116 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
117 want.SetParam(FROM_REMOTE_KEY, true);
118 // mock callerToken
119 const sptr<IRemoteObject> callerToken = MockToken();
120 int res = 0;
121
122 usleep(100000); // 100000 means us.
123 // from freeInstallManager_->freeInstallList_ find startInstallTime
124 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
125 std::string bundleName = (*it).want.GetElement().GetBundleName();
126 std::string abilityName = (*it).want.GetElement().GetAbilityName();
127 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
128 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
129 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
130 break;
131 }
132 }
133 res = freeInstallManager_->RemoteFreeInstall(want, userId, requestCode, callerToken);
134 EXPECT_NE(res, ERR_OK);
135 }
136
137 /**
138 * @tc.number: StartRemoteFreeInstall_001
139 * @tc.name: StartRemoteFreeInstall
140 * @tc.desc: Test StartRemoteFreeInstall.
141 */
142 HWTEST_F(FreeInstallTest, FreeInstall_StartRemoteFreeInstall_001, TestSize.Level1)
143 {
144 auto abilityMs_ = std::make_shared<AbilityManagerService>();
145 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
146 Want want;
147 ElementName element("", "com.test.demo", "MainAbility");
148 want.SetElement(element);
149 const int32_t userId = 100;
150 const int requestCode = 0;
151 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
152 want.SetParam(Want::PARAM_RESV_FOR_RESULT, true);
153 // mock callerToken
154 const sptr<IRemoteObject> callerToken = MockToken();
155 int res = 0;
156
157 usleep(100000); // 100000 means us.
158 // from freeInstallManager_->freeInstallList_ find startInstallTime
159 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
160 std::string bundleName = (*it).want.GetElement().GetBundleName();
161 std::string abilityName = (*it).want.GetElement().GetAbilityName();
162 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
163 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
164 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
165 break;
166 }
167 }
168 res = freeInstallManager_->StartRemoteFreeInstall(want, userId, requestCode, callerToken);
169 EXPECT_NE(res, ERR_OK);
170 }
171
172 /**
173 * @tc.number: StartRemoteFreeInstall_002
174 * @tc.name: StartRemoteFreeInstall
175 * @tc.desc: Test StartRemoteFreeInstall.
176 */
177 HWTEST_F(FreeInstallTest, FreeInstall_StartRemoteFreeInstall_002, TestSize.Level1)
178 {
179 auto abilityMs_ = std::make_shared<AbilityManagerService>();
180 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
181 Want want;
182 ElementName element("", "com.test.demo", "MainAbility");
183 want.SetElement(element);
184 const int32_t userId = 100;
185 const int requestCode = 0;
186 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
187 want.SetParam(Want::PARAM_RESV_FOR_RESULT, false);
188 // mock callerToken
189 const sptr<IRemoteObject> callerToken = MockToken();
190 int res = 0;
191 usleep(100000); // 100000 means us.
192 // from freeInstallManager_->freeInstallList_ find startInstallTime
193 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
194 std::string bundleName = (*it).want.GetElement().GetBundleName();
195 std::string abilityName = (*it).want.GetElement().GetAbilityName();
196 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
197 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
198 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
199 break;
200 }
201 }
202 res = freeInstallManager_->StartRemoteFreeInstall(want, userId, requestCode, callerToken);
203 EXPECT_NE(res, ERR_OK);
204 }
205
206 /**
207 * @tc.number: NotifyDmsCallback_001
208 * @tc.name: NotifyDmsCallback
209 * @tc.desc: Test NotifyDmsCallback.
210 */
211 HWTEST_F(FreeInstallTest, FreeInstall_NotifyDmsCallback_001, TestSize.Level1)
212 {
213 auto abilityMs_ = std::make_shared<AbilityManagerService>();
214 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
215 Want want;
216 ElementName element("", "com.test.demo", "MainAbility");
217 want.SetElement(element);
218 const int32_t userId = 100;
219 const int requestCode = 0;
220 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
221 int res = 0;
222 res = freeInstallManager_->NotifyDmsCallback(want, requestCode);
223 EXPECT_EQ(res, ERR_INVALID_VALUE);
224 }
225
226 /**
227 * @tc.number: HandleOnFreeInstallSuccess_001
228 * @tc.name: HandleOnFreeInstallSuccess
229 * @tc.desc: Test HandleOnFreeInstallSuccess.
230 */
231 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallSuccess_001, TestSize.Level1)
232 {
233 auto abilityMs_ = std::make_shared<AbilityManagerService>();
234 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
235 Want want;
236 ElementName element("", "com.test.demo", "MainAbility");
237 want.SetElement(element);
238 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
239 int32_t recordId = 100;
240 FreeInstallInfo freeInstallInfo;
241 freeInstallInfo.want = want;
242 bool isAsync = true;
243 freeInstallInfo.isPreStartMissionCalled = true;
244 freeInstallManager_->HandleOnFreeInstallSuccess(recordId, freeInstallInfo, isAsync);
245 EXPECT_EQ(freeInstallInfo.isOpenAtomicServiceShortUrl, false);
246 }
247
248 /**
249 * @tc.number: HandleOnFreeInstallSuccess_002
250 * @tc.name: HandleOnFreeInstallSuccess
251 * @tc.desc: Test HandleOnFreeInstallSuccess.
252 */
253 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallSuccess_002, TestSize.Level1)
254 {
255 auto abilityMs_ = std::make_shared<AbilityManagerService>();
256 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
257 Want want;
258 ElementName element("", "com.test.demo", "MainAbility");
259 want.SetElement(element);
260 int32_t recordId = 100;
261 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
262 FreeInstallInfo freeInstallInfo;
263 freeInstallInfo.want = want;
264 bool isAsync = true;
265 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
266 freeInstallManager_->HandleOnFreeInstallSuccess(recordId, freeInstallInfo, isAsync);
267 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
268 }
269
270 /**
271 * @tc.number: HandleOnFreeInstallFail_001
272 * @tc.name: HandleOnFreeInstallFail
273 * @tc.desc: Test HandleOnFreeInstallFail.
274 */
275 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallFail_001, TestSize.Level1)
276 {
277 auto abilityMs_ = std::make_shared<AbilityManagerService>();
278 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
279 Want want;
280 ElementName element("", "com.ohos.param.sessionId", "MainAbility");
281 want.SetElement(element);
282 int32_t recordId = 100;
283 int resultCode = 0;
284 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
285 FreeInstallInfo freeInstallInfo;
286 freeInstallInfo.want = want;
287 bool isAsync = true;
288 freeInstallInfo.isPreStartMissionCalled = true;
289 freeInstallInfo.isStartUIAbilityBySCBCalled = true;
290 freeInstallManager_->HandleOnFreeInstallFail(recordId, freeInstallInfo, resultCode, isAsync);
291 EXPECT_EQ(freeInstallInfo.isOpenAtomicServiceShortUrl, false);
292 }
293
294 /**
295 * @tc.number: HandleOnFreeInstallFail_002
296 * @tc.name: HandleOnFreeInstallFail
297 * @tc.desc: Test HandleOnFreeInstallFail.
298 */
299 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallFail_002, TestSize.Level1)
300 {
301 auto abilityMs_ = std::make_shared<AbilityManagerService>();
302 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
303 Want want;
304 ElementName element("", "com.ohos.param.sessionId", "MainAbility");
305 want.SetElement(element);
306 int32_t recordId = 100;
307 int resultCode = 0;
308 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
309 FreeInstallInfo freeInstallInfo;
310 freeInstallInfo.want = want;
311 bool isAsync = true;
312 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
313 freeInstallManager_->HandleOnFreeInstallFail(recordId, freeInstallInfo, resultCode, isAsync);
314 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
315 }
316
317 /**
318 * @tc.number: StartAbilityByFreeInstall_001
319 * @tc.name: StartAbilityByFreeInstall
320 * @tc.desc: Test StartAbilityByFreeInstall.
321 */
322 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByFreeInstall_001, TestSize.Level1)
323 {
324 auto abilityMs_ = std::make_shared<AbilityManagerService>();
325 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
326 Want want;
327 ElementName element("", "com.test.demo", "MainAbility");
328 want.SetElement(element);
329 FreeInstallInfo freeInstallInfo;
330 std::string bundleName = "com.test.demo";
331 std::string abilityName = "MainAbility";
332 std::string startTime = "2024-7-17 00:00:00";
333 std::shared_ptr<FreeInstallParams> param = std::make_shared<FreeInstallParams>();
334 freeInstallInfo.startOptions = param->startOptions;
335 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
336 freeInstallInfo.want = want;
337 freeInstallManager_->StartAbilityByFreeInstall(freeInstallInfo, bundleName, abilityName, startTime);
338 freeInstallInfo.startOptions = nullptr;
339 freeInstallManager_->StartAbilityByFreeInstall(freeInstallInfo, bundleName, abilityName, startTime);
340 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
341 }
342
343 /**
344 * @tc.number: StartAbilityByFreeInstall_002
345 * @tc.name: StartAbilityByFreeInstall
346 * @tc.desc: Test StartAbilityByFreeInstall.
347 */
348 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByFreeInstall_002, TestSize.Level1)
349 {
350 auto abilityMs_ = std::make_shared<AbilityManagerService>();
351 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
352 Want want;
353 ElementName element("", "", "");
354 want.SetElement(element);
355 FreeInstallInfo freeInstallInfo;
356 std::string bundleName = "com.test.demo";
357 std::string abilityName = "MainAbility";
358 std::string startTime = "2024-7-17 00:00:00";
359 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
360 freeInstallInfo.want = want;
361 freeInstallManager_->StartAbilityByFreeInstall(freeInstallInfo, bundleName, abilityName, startTime);
362 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
363 }
364
365 /**
366 * @tc.number: StartAbilityByPreInstall_001
367 * @tc.name: StartAbilityByPreInstall
368 * @tc.desc: Test StartAbilityByPreInstall.
369 */
370 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByPreInstall_001, TestSize.Level1)
371 {
372 auto abilityMs_ = std::make_shared<AbilityManagerService>();
373 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
374 Want want;
375 ElementName element("", "com.test.demo", "MainAbility");
376 want.SetElement(element);
377 FreeInstallInfo freeInstallInfo;
378 std::string bundleName = "com.test.demo";
379 std::string abilityName = "MainAbility";
380 std::string startTime = "2024-7-17 00:00:00";
381 std::shared_ptr<FreeInstallParams> param = std::make_shared<FreeInstallParams>();
382 freeInstallInfo.startOptions = param->startOptions;
383 int32_t recordId = 100;
384 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
385 freeInstallInfo.want = want;
386 freeInstallInfo.isStartUIAbilityBySCBCalled = true;
387 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
388 freeInstallManager_->StartAbilityByPreInstall(recordId, freeInstallInfo, bundleName, abilityName, startTime);
389 freeInstallInfo.startOptions = nullptr;
390 freeInstallManager_->StartAbilityByPreInstall(recordId, freeInstallInfo, bundleName, abilityName, startTime);
391 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
392 }
393
394 /**
395 * @tc.number: StartAbilityByPreInstall_002
396 * @tc.name: StartAbilityByPreInstall
397 * @tc.desc: Test StartAbilityByPreInstall.
398 */
399 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByPreInstall_002, TestSize.Level1)
400 {
401 auto abilityMs_ = std::make_shared<AbilityManagerService>();
402 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
403 Want want;
404 ElementName element("", "", "");
405 want.SetElement(element);
406 int32_t recordId = 100;
407 FreeInstallInfo freeInstallInfo;
408 std::string bundleName = "com.test.demo";
409 std::string abilityName = "MainAbility";
410 std::string startTime = "2024-7-17 00:00:00";
411 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
412 freeInstallInfo.want = want;
413 freeInstallManager_->StartAbilityByPreInstall(recordId, freeInstallInfo, bundleName, abilityName, startTime);
414 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
415 }
416
417 /**
418 * @tc.number: SetSCBCallStatus_001
419 * @tc.name: SetSCBCallStatus
420 * @tc.desc: Test SetSCBCallStatus.
421 */
422 HWTEST_F(FreeInstallTest, FreeInstall_SetSCBCallStatus_001, TestSize.Level1)
423 {
424 auto abilityMs_ = std::make_shared<AbilityManagerService>();
425 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
426 Want want;
427 ElementName element("", "com.test.demo", "MainAbility");
428 want.SetElement(element);
429 std::string bundleName = "com.test.demo";
430 std::string abilityName = "MainAbility";
431 std::string startTime = "2024-7-17 00:00:00";
432 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
433 const int32_t userId = 1;
434 const int requestCode = 0;
435 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
436 {
437 std::lock_guard<ffrt::mutex> lock(freeInstallManager_->freeInstallListLock_);
438 freeInstallManager_->freeInstallList_.push_back(info);
439 }
440 bool scbCallStatus = true;
441 freeInstallManager_->SetSCBCallStatus(bundleName, abilityName, startTime, scbCallStatus);
442 EXPECT_EQ(info.isStartUIAbilityBySCBCalled, false);
443 }
444
445 /**
446 * @tc.number: SetPreStartMissionCallStatus_001
447 * @tc.name: SetPreStartMissionCallStatus
448 * @tc.desc: Test SetPreStartMissionCallStatus.
449 */
450 HWTEST_F(FreeInstallTest, FreeInstall_SetPreStartMissionCallStatus_001, TestSize.Level1)
451 {
452 auto abilityMs_ = std::make_shared<AbilityManagerService>();
453 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
454 Want want;
455 ElementName element("", "com.test.demo", "MainAbility");
456 want.SetElement(element);
457 std::string bundleName = "com.test.demo";
458 std::string abilityName = "MainAbility";
459 std::string startTime = "2024-7-17 00:00:00";
460 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
461 const int32_t userId = 1;
462 const int requestCode = 0;
463 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
464 {
465 std::lock_guard<ffrt::mutex> lock(freeInstallManager_->freeInstallListLock_);
466 freeInstallManager_->freeInstallList_.push_back(info);
467 }
468 bool preStartMissionCallStatus = true;
469 freeInstallManager_->SetPreStartMissionCallStatus(bundleName, abilityName, startTime, preStartMissionCallStatus);
470 EXPECT_EQ(info.isPreStartMissionCalled, false);
471 }
472 } // namespace AppExecFwk
473 } // namespace OHOS