1 /*
2 * Copyright (c) 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 #include "ability_manager_service.h"
20 #include "task_handler_wrap.h"
21 #undef private
22
23 #include "ability_record.h"
24 #include "sa_mgr_client.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::AAFwk;
28
29 namespace OHOS {
30 namespace AppExecFwk {
31 namespace {
32 const int BUNDLE_MGR_SERVICE_SYS_ABILITY_ID = 401;
33 }
34 class FreeInstallTest : public testing::Test {
35 public:
FreeInstallTest()36 FreeInstallTest()
37 {}
~FreeInstallTest()38 ~FreeInstallTest()
39 {}
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 sptr<Token> MockToken();
45 std::shared_ptr<FreeInstallManager> freeInstallManager_ = nullptr;
46 };
47
SetUpTestCase(void)48 void FreeInstallTest::SetUpTestCase(void) {}
49
TearDownTestCase(void)50 void FreeInstallTest::TearDownTestCase(void) {}
51
SetUp(void)52 void FreeInstallTest::SetUp(void) {}
53
TearDown(void)54 void FreeInstallTest::TearDown(void)
55 {}
56
MockToken()57 sptr<Token> FreeInstallTest::MockToken()
58 {
59 sptr<Token> token = nullptr;
60 AbilityRequest abilityRequest;
61 abilityRequest.appInfo.bundleName = "com.test.demo";
62 abilityRequest.abilityInfo.name = "MainAbility";
63 abilityRequest.abilityInfo.type = AbilityType::PAGE;
64 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
65 if (!abilityRecord) {
66 return nullptr;
67 }
68 return abilityRecord->GetToken();
69 }
70
71 /**
72 * @tc.number: FreeInstall_StartFreeInstall_001
73 * @tc.name: StartFreeInstall
74 * @tc.desc: Test StartFreeInstall when callback is success.
75 */
76 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_001, TestSize.Level1)
77 {
78 auto abilityMs_ = std::make_shared<AbilityManagerService>();
79 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
80 Want want;
81 ElementName element("", "com.test.demo", "MainAbility");
82 want.SetElement(element);
83 const int32_t userId = 100;
84 const int requestCode = 0;
85 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
86 // mock callerToken
87 const sptr<IRemoteObject> callerToken = MockToken();
88 int res = 0;
89
90 usleep(100000);
91 // from freeInstallManager_->freeInstallList_ find startInstallTime
92 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
93 std::string bundleName = (*it).want.GetElement().GetBundleName();
94 std::string abilityName = (*it).want.GetElement().GetAbilityName();
95 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
96 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
97 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
98 break;
99 }
100 }
101 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
102
103 EXPECT_EQ(res, 0);
104 }
105
106 /**
107 * @tc.number: FreeInstall_StartFreeInstall_002
108 * @tc.name: StartFreeInstall
109 * @tc.desc: Test StartFreeInstall when token is nullptr.
110 */
111 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_002, TestSize.Level1)
112 {
113 auto abilityMs_ = std::make_shared<AbilityManagerService>();
114 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
115 Want want;
116 ElementName element("", "com.test.demo", "MainAbility");
117 want.SetElement(element);
118 const int32_t userId = 100;
119 const int requestCode = 0;
120 // token is nullptr, IsTopAbility failed
121 const sptr<IRemoteObject> callerToken = nullptr;
122 // NotTopAbility
123 int res = freeInstallManager_->StartFreeInstall(want, userId, requestCode, callerToken);
124 EXPECT_EQ(res, UNKNOWN_EXCEPTION);
125 }
126
127 /**
128 * @tc.number: FreeInstall_StartFreeInstall_003
129 * @tc.name: StartFreeInstall
130 * @tc.desc: Test StartFreeInstall when callback is failed.
131 */
132 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_003, TestSize.Level1)
133 {
134 auto abilityMs_ = std::make_shared<AbilityManagerService>();
135 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
136 Want want;
137 ElementName element("", "com.test.demo", "MainAbility");
138 want.SetElement(element);
139 const int32_t userId = 1;
140 const int requestCode = 0;
141 // mock callerToken
142 const sptr<IRemoteObject> callerToken = MockToken();
143 int res = 0;
144
145 usleep(100000);
146 // from freeInstallManager_->freeInstallList_ find startInstallTime
147 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
148 std::string bundleName = (*it).want.GetElement().GetBundleName();
149 std::string abilityName = (*it).want.GetElement().GetAbilityName();
150 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
151 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
152 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
153 break;
154 }
155 }
156 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
157
158 EXPECT_EQ(res, 0);
159 }
160
161 /**
162 * @tc.number: FreeInstall_OnInstallFinished_001
163 * @tc.name: OnInstallFinished
164 * @tc.desc: Test OnInstallFinished succeed.
165 */
166 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_001, TestSize.Level1)
167 {
168 auto abilityMs_ = std::make_shared<AbilityManagerService>();
169 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
170 Want want;
171 ElementName element("", "com.test.demo", "MainAbility");
172 want.SetElement(element);
173 const int32_t userId = 1;
174 const int requestCode = 0;
175 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
176
177 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr, false);
178 freeInstallManager_->freeInstallList_.resize(0);
179 freeInstallManager_->freeInstallList_.emplace_back(info);
180 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
181
182 for (auto it = freeInstallManager_->freeInstallList_.begin();
183 it != freeInstallManager_->freeInstallList_.end(); it++) {
184 std::string bundleName = (*it).want.GetElement().GetBundleName();
185 std::string abilityName = (*it).want.GetElement().GetAbilityName();
186 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
187 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
188 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
189 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
190 EXPECT_EQ((*it).promise->get_future().get(), 0);
191 }
192 }
193 }
194
195 /**
196 * @tc.number: FreeInstall_OnInstallFinished_002
197 * @tc.name: OnInstallFinished
198 * @tc.desc: Test OnInstallFinished failed.
199 */
200 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_002, TestSize.Level1)
201 {
202 auto abilityMs_ = std::make_shared<AbilityManagerService>();
203 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
204 Want want;
205 ElementName element("", "com.test.demo", "MainAbility");
206 want.SetElement(element);
207 const int32_t userId = 1;
208 const int requestCode = 0;
209 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
210
211 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr, false);
212 freeInstallManager_->freeInstallList_.resize(0);
213 freeInstallManager_->freeInstallList_.emplace_back(info);
214 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
215
216 for (auto it = freeInstallManager_->freeInstallList_.begin();
217 it != freeInstallManager_->freeInstallList_.end(); it++) {
218 std::string bundleName = (*it).want.GetElement().GetBundleName();
219 std::string abilityName = (*it).want.GetElement().GetAbilityName();
220 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
221 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
222 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
223 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
224 EXPECT_EQ((*it).promise->get_future().get(), 1);
225 }
226 }
227 }
228
229 /**
230 * @tc.number: FreeInstall_OnInstallFinished_003
231 * @tc.name: OnInstallFinished
232 * @tc.desc: Test OnInstallFinished failed.
233 */
234 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_003, TestSize.Level1)
235 {
236 auto abilityMs_ = std::make_shared<AbilityManagerService>();
237 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
238 Want want;
239 ElementName element("", "com.test.demo", "MainAbility");
240 want.SetElement(element);
241 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
242 const int32_t userId = 1;
243 const int requestCode = 0;
244
245 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr, false);
246 info.isInstalled = true;
247 freeInstallManager_->freeInstallList_.resize(0);
248 info.promise.reset();
249 freeInstallManager_->freeInstallList_.emplace_back(info);
250 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
251
252 int size = freeInstallManager_->freeInstallList_.size();
253 EXPECT_EQ(size, 1);
254 }
255
256 /**
257 * @tc.number: FreeInstall_FreeInstallAbilityFromRemote_001
258 * @tc.name: FreeInstallAbilityFromRemote
259 * @tc.desc: Test FreeInstallAbilityFromRemote.
260 */
261 HWTEST_F(FreeInstallTest, FreeInstall_FreeInstallAbilityFromRemote_001, TestSize.Level1)
262 {
263 auto abilityMs_ = std::make_shared<AbilityManagerService>();
264 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
265 Want want;
266 ElementName element("", "com.test.demo", "MainAbility");
267 want.SetElement(element);
268 const int32_t userId = 1;
269 const int requestCode = 0;
270
271 int res = freeInstallManager_->FreeInstallAbilityFromRemote(want, nullptr, userId, requestCode);
272 EXPECT_EQ(res, 22);
273 }
274
275 /**
276 * @tc.number: FreeInstall_OnRemoteInstallFinished_001
277 * @tc.name: OnRemoteInstallFinished
278 * @tc.desc: Test OnRemoteInstallFinished.
279 */
280 HWTEST_F(FreeInstallTest, FreeInstall_OnRemoteInstallFinished_001, TestSize.Level1)
281 {
282 auto abilityMs_ = std::make_shared<AbilityManagerService>();
283 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
284 Want want;
285 ElementName element("", "com.test.demo", "MainAbility");
286 want.SetElement(element);
287 const int32_t userId = 1;
288 const int requestCode = 0;
289 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
290
291 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr, false);
292 freeInstallManager_->freeInstallList_.resize(0);
293 freeInstallManager_->freeInstallList_.emplace_back(info);
294 freeInstallManager_->OnRemoteInstallFinished(-1, 0, want, userId);
295
296 for (auto it = freeInstallManager_->freeInstallList_.begin();
297 it != freeInstallManager_->freeInstallList_.end(); it++) {
298 std::string bundleName = (*it).want.GetElement().GetBundleName();
299 std::string abilityName = (*it).want.GetElement().GetAbilityName();
300 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
301 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
302 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
303 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
304 EXPECT_EQ((*it).promise->get_future().get(), 0);
305 }
306 }
307 }
308
309 /**
310 * @tc.number: FreeInstall_ConnectFreeInstall_001
311 * @tc.name: ConnectFreeInstall
312 * @tc.desc: Test ConnectFreeInstall.
313 */
314 HWTEST_F(FreeInstallTest, FreeInstall_ConnectFreeInstall_001, TestSize.Level1)
315 {
316 auto abilityMs_ = std::make_shared<AbilityManagerService>();
317 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
318 Want want;
319 ElementName element("", "com.test.demo", "MainAbility");
320 want.SetElement(element);
321 const int32_t userId = 1;
322
323 int res = freeInstallManager_->ConnectFreeInstall(want, userId, nullptr, "");
324 EXPECT_NE(res, 0);
325 }
326
327
328 /**
329 * @tc.number: FreeInstall_UpdateElementName_001
330 * @tc.name: UpdateElementName
331 * @tc.desc: Test UpdateElementName.
332 */
333 HWTEST_F(FreeInstallTest, FreeInstall_UpdateElementName_001, TestSize.Level1)
334 {
335 auto abilityMs_ = std::make_shared<AbilityManagerService>();
336 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
337 Want want;
338 const int32_t userId = 1;
339 freeInstallManager_->UpdateElementName(want, userId);
340 freeInstallManager_->GetTimeStamp();
341 }
342
343 /**
344 * @tc.number: FreeInstall_AddFreeInstallObserver_001
345 * @tc.name: AddFreeInstallObserver
346 * @tc.desc: Test AddFreeInstallObserver.
347 */
348 HWTEST_F(FreeInstallTest, FreeInstall_AddFreeInstallObserver_001, TestSize.Level1)
349 {
350 auto abilityMs_ = std::make_shared<AbilityManagerService>();
351 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
352
353 const sptr<IRemoteObject> callerToken = MockToken();
354 freeInstallManager_->AddFreeInstallObserver(nullptr, nullptr);
355
356 freeInstallManager_->AddFreeInstallObserver(callerToken, nullptr);
357 }
358
359 /**
360 * @tc.number: FreeInstall_RemoveFreeInstallInfo_001
361 * @tc.name: RemoveFreeInstallInfo
362 * @tc.desc: Test RemoveFreeInstallInfo.
363 */
364 HWTEST_F(FreeInstallTest, FreeInstall_RemoveFreeInstallInfo_001, TestSize.Level1)
365 {
366 auto abilityMs_ = std::make_shared<AbilityManagerService>();
367 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
368
369 freeInstallManager_->RemoveFreeInstallInfo("com.ix.hiservcie", "ServiceAbility", "2024-7-17 00:00:00");
370 }
371
372 /**
373 * @tc.number: FreeInstall_GetFreeInstallTaskInfo_001
374 * @tc.name: GetFreeInstallTaskInfo
375 * @tc.desc: Test GetFreeInstallTaskInfo.
376 */
377 HWTEST_F(FreeInstallTest, FreeInstall_GetFreeInstallTaskInfo_001, TestSize.Level1)
378 {
379 auto abilityMs_ = std::make_shared<AbilityManagerService>();
380 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
381
382 FreeInstallInfo freeInstallInfo;
383 freeInstallManager_->GetFreeInstallTaskInfo("sessionId", freeInstallInfo);
384 }
385
386 /**
387 * @tc.number: FreeInstall_SetSCBCallStatus_001
388 * @tc.name: SetSCBCallStatus
389 * @tc.desc: Test SetSCBCallStatus.
390 */
391 HWTEST_F(FreeInstallTest, FreeInstall_SetSCBCallStatus_001, TestSize.Level1)
392 {
393 auto abilityMs_ = std::make_shared<AbilityManagerService>();
394 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
395
396 freeInstallManager_->SetSCBCallStatus("com.ix.hiservcie", "ServiceAbility", "2024-7-17 00:00:00", false);
397 }
398
399 /**
400 * @tc.number: FreeInstall_SetPreStartMissionCallStatus_001
401 * @tc.name: SetPreStartMissionCallStatus
402 * @tc.desc: Test SetPreStartMissionCallStatus.
403 */
404 HWTEST_F(FreeInstallTest, FreeInstall_SetPreStartMissionCallStatus_001, TestSize.Level1)
405 {
406 auto abilityMs_ = std::make_shared<AbilityManagerService>();
407 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
408
409 freeInstallManager_->SetPreStartMissionCallStatus("com.ix.hiservcie", "ServiceAbility",
410 "2024-7-17 00:00:00", false);
411 }
412
413 /**
414 * @tc.number: FreeInstall_SetFreeInstallTaskSessionId_001
415 * @tc.name: SetFreeInstallTaskSessionId
416 * @tc.desc: Test SetFreeInstallTaskSessionId.
417 */
418 HWTEST_F(FreeInstallTest, FreeInstall_SetFreeInstallTaskSessionId_001, TestSize.Level1)
419 {
420 auto abilityMs_ = std::make_shared<AbilityManagerService>();
421 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
422
423 freeInstallManager_->SetFreeInstallTaskSessionId("com.ix.hiservcie", "ServiceAbility",
424 "2024-7-17 00:00:00", "sessionId");
425 }
426
427 /**
428 * @tc.number: FreeInstall_VerifyStartFreeInstallPermission_001
429 * @tc.name: VerifyStartFreeInstallPermission
430 * @tc.desc: Test VerifyStartFreeInstallPermission.
431 */
432 HWTEST_F(FreeInstallTest, FreeInstall_VerifyStartFreeInstallPermission_001, TestSize.Level1)
433 {
434 auto abilityMs_ = std::make_shared<AbilityManagerService>();
435 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
436
437 const sptr<IRemoteObject> callerToken = MockToken();
438 freeInstallManager_->VerifyStartFreeInstallPermission(callerToken);
439 freeInstallManager_->GetRecordIdByToken(callerToken);
440 }
441
442 /**
443 * @tc.number: FreeInstall_SetAppRunningState_001
444 * @tc.name: SetAppRunningState
445 * @tc.desc: Test SetAppRunningState.
446 */
447 HWTEST_F(FreeInstallTest, FreeInstall_SetAppRunningState_001, TestSize.Level1)
448 {
449 auto abilityMs_ = std::make_shared<AbilityManagerService>();
450 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
451
452 Want want;
453 freeInstallManager_->SetAppRunningState(want);
454 }
455
456 /**
457 * @tc.number: FreeInstall_PostUpgradeAtomicServiceTask_001
458 * @tc.name: PostUpgradeAtomicServiceTask
459 * @tc.desc: Test PostUpgradeAtomicServiceTask.
460 */
461 HWTEST_F(FreeInstallTest, FreeInstall_PostUpgradeAtomicServiceTask_001, TestSize.Level1)
462 {
463 auto abilityMs_ = std::make_shared<AbilityManagerService>();
464 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
465
466 Want want;
467 ElementName element("", "com.test.demo", "MainAbility");
468 want.SetElement(element);
469 const int32_t userId = 100;
470 int resultCode = 0;
471 freeInstallManager_->PostUpgradeAtomicServiceTask(resultCode, want, userId);
472 }
473
474 /**
475 * @tc.number: FreeInstall_StartAbilityByOriginalWant_001
476 * @tc.name: StartAbilityByOriginalWant
477 * @tc.desc: Test StartAbilityByOriginalWant.
478 */
479 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByOriginalWant_001, TestSize.Level1)
480 {
481 auto abilityMs_ = std::make_shared<AbilityManagerService>();
482 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
483
484 FreeInstallInfo freeInstallInfo;
485 freeInstallManager_->StartAbilityByOriginalWant(freeInstallInfo, "2024-07-17 00:00:00");
486 }
487
488 /**
489 * @tc.number: FreeInstall_StartAbilityByConvertedWant_001
490 * @tc.name: StartAbilityByConvertedWant
491 * @tc.desc: Test StartAbilityByConvertedWant.
492 */
493 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByConvertedWant_001, TestSize.Level1)
494 {
495 auto abilityMs_ = std::make_shared<AbilityManagerService>();
496 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
497
498 FreeInstallInfo freeInstallInfo;
499 freeInstallManager_->StartAbilityByConvertedWant(freeInstallInfo, "2024-07-17 00:00:00");
500 }
501
502 } // namespace AppExecFwk
503 } // namespace OHOS