1 /*
2 * Copyright (c) 2024-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 #include <string>
18
19 #include "accesstoken_kit_mock.h"
20 #include "app_gallery_dispose_proxy_mock.h"
21 #include "backup_para_mock.h"
22 #include "bms_adapter_mock.h"
23 #include "b_json_clear_data_config_mock.h"
24 #include "b_json_service_disposal_config_mock.h"
25 #include "b_json/b_json_entity_caps.h"
26 #include "b_jsonutil_mock.h"
27 #include "b_sa_utils_mock.h"
28 #include "ipc_skeleton_mock.h"
29 #include "notify_work_service_mock.h"
30 #include "sa_backup_connection_mock.h"
31 #include "service_reverse_proxy_mock.h"
32 #include "sms_adapter_mock.h"
33 #include "svc_backup_connection_mock.h"
34 #include "svc_extension_proxy_mock.h"
35 #include "svc_restore_deps_manager_mock.h"
36 #include "svc_session_manager_mock.h"
37 #include "system_ability_mock.h"
38
39 #include "service.cpp"
40 #include "sub_service.cpp"
41
42 namespace OHOS::FileManagement::Backup {
AppendBundlesIncrementalBackupSessionWithBundleInfos(const std::vector<BIncrementalData> & bundlesToBackup,const std::vector<std::string> & bundleInfos)43 ErrCode Service::AppendBundlesIncrementalBackupSessionWithBundleInfos(
44 const std::vector<BIncrementalData> &bundlesToBackup,
45 const std::vector<std::string> &bundleInfos)
46 {
47 return BError(BError::Codes::OK);
48 }
PublishSAIncrementalFile(const BFileInfo & fileInfo,int fd)49 ErrCode Service::PublishSAIncrementalFile(const BFileInfo &fileInfo, int fd)
50 {
51 return BError(BError::Codes::OK);
52 }
AppIncrementalFileReady(const std::string & fileName,int fd,int manifestFd,int32_t appIncrementalFileReadyErrCode)53 ErrCode Service::AppIncrementalFileReady(const std::string &fileName,
54 int fd,
55 int manifestFd,
56 int32_t appIncrementalFileReadyErrCode)
57 {
58 return BError(BError::Codes::OK);
59 }
60
AppIncrementalFileReadyWithoutFd(const std::string & fileName,int32_t appIncrementalFileReadyErrCode)61 ErrCode Service::AppIncrementalFileReadyWithoutFd(const std::string &fileName,
62 int32_t appIncrementalFileReadyErrCode)
63 {
64 return BError(BError::Codes::OK);
65 }
66
Release()67 ErrCode Service::Release()
68 {
69 return BError(BError::Codes::OK);
70 }
71
CancelForResult(const std::string & bundleName,int32_t & result)72 ErrCode Service::CancelForResult(const std::string& bundleName, int32_t &result)
73 {
74 result = BError(BError::Codes::OK);
75 return BError(BError::Codes::OK);
76 }
77
GetLocalCapabilitiesIncremental(const std::vector<BIncrementalData> & bundleNames,int & fd)78 ErrCode Service::GetLocalCapabilitiesIncremental(const std::vector<BIncrementalData> &bundleNames, int &fd)
79 {
80 return BError(BError::Codes::OK);
81 }
82
StartGetFdTask(std::string,wptr<Service>)83 void Service::StartGetFdTask(std::string, wptr<Service>) {}
84
GetAppLocalListAndDoIncrementalBackup()85 ErrCode Service::GetAppLocalListAndDoIncrementalBackup()
86 {
87 return BError(BError::Codes::OK);
88 }
89
InitIncrementalBackupSession(const sptr<IServiceReverse> &)90 ErrCode Service::InitIncrementalBackupSession(const sptr<IServiceReverse> &)
91 {
92 return BError(BError::Codes::OK);
93 }
94
InitIncrementalBackupSessionWithErrMsg(const sptr<IServiceReverse> &,int32_t & errCodeForMsg,std::string &)95 ErrCode Service::InitIncrementalBackupSessionWithErrMsg(const sptr<IServiceReverse>&,
96 int32_t &errCodeForMsg, std::string &)
97 {
98 errCodeForMsg = BError(BError::Codes::OK);
99 return BError(BError::Codes::OK);
100 }
101
GetBundleNameByDetails(const std::vector<BIncrementalData> &)102 vector<string> Service::GetBundleNameByDetails(const std::vector<BIncrementalData>&)
103 {
104 return {};
105 }
106
AppendBundlesIncrementalBackupSession(const std::vector<BIncrementalData> &)107 ErrCode Service::AppendBundlesIncrementalBackupSession(const std::vector<BIncrementalData>&)
108 {
109 return BError(BError::Codes::OK);
110 }
111
AppendBundlesIncrementalBackupSession(const std::vector<BIncrementalData> &,const std::vector<std::string> &)112 ErrCode Service::AppendBundlesIncrementalBackupSession(const std::vector<BIncrementalData>&,
113 const std::vector<std::string>&)
114 {
115 return BError(BError::Codes::OK);
116 }
117
PublishIncrementalFile(const BFileInfo &)118 ErrCode Service::PublishIncrementalFile(const BFileInfo&)
119 {
120 return BError(BError::Codes::OK);
121 }
122
PublishSAIncrementalFile(const BFileInfo &,UniqueFd)123 ErrCode Service::PublishSAIncrementalFile(const BFileInfo&, UniqueFd)
124 {
125 return BError(BError::Codes::OK);
126 }
127
AppIncrementalFileReady(const std::string &,UniqueFd,UniqueFd,int32_t)128 ErrCode Service::AppIncrementalFileReady(const std::string&, UniqueFd, UniqueFd, int32_t)
129 {
130 return BError(BError::Codes::OK);
131 }
132
AppIncrementalDone(ErrCode)133 ErrCode Service::AppIncrementalDone(ErrCode)
134 {
135 return BError(BError::Codes::OK);
136 }
137
GetIncrementalFileHandle(const std::string &,const std::string &)138 ErrCode Service::GetIncrementalFileHandle(const std::string&, const std::string&)
139 {
140 return BError(BError::Codes::OK);
141 }
142
IncrementalBackup(const string &)143 bool Service::IncrementalBackup(const string&)
144 {
145 return false;
146 }
147
IncrementalBackupSA(std::string bundleName)148 ErrCode Service::IncrementalBackupSA(std::string bundleName)
149 {
150 return BError(BError::Codes::OK);
151 }
152
NotifyCallerCurAppIncrementDone(ErrCode,const std::string &)153 void Service::NotifyCallerCurAppIncrementDone(ErrCode, const std::string&) {}
154
SendUserIdToApp(string &,int32_t)155 void Service::SendUserIdToApp(string&, int32_t) {}
156
SetCurrentBackupSessProperties(const vector<string> &,int32_t,std::vector<BJsonEntityCaps::BundleInfo> &,bool)157 void Service::SetCurrentBackupSessProperties(const vector<string> &,
158 int32_t,
159 std::vector<BJsonEntityCaps::BundleInfo> &,
160 bool)
161 {
162 }
163
GetExtensionMutex(const BundleName & bundleName)164 std::shared_ptr<ExtensionMutexInfo> Service::GetExtensionMutex(const BundleName &bundleName)
165 {
166 return make_shared<ExtensionMutexInfo>(bundleName);
167 }
168
RemoveExtensionMutex(const BundleName &)169 void Service::RemoveExtensionMutex(const BundleName&) {}
170
CreateDirIfNotExist(const std::string &)171 void Service::CreateDirIfNotExist(const std::string&) {}
172
UpdateDfxInfo(const std::string & bundleName,uint64_t uniqId)173 void SvcSessionManager::UpdateDfxInfo(const std::string &bundleName, uint64_t uniqId) {}
174 }
175
176 class BThreadPool {
177 public:
178 virtual void AddTask(const OHOS::ThreadPool::Task&) = 0;
179 public:
180 BThreadPool() = default;
181 virtual ~BThreadPool() = default;
182 public:
183 static inline std::shared_ptr<BThreadPool> task = nullptr;
184 };
185
186 class ThreadPoolMock : public BThreadPool {
187 public:
188 MOCK_METHOD(void, AddTask, (const OHOS::ThreadPool::Task&));
189 };
190
AddTask(const OHOS::ThreadPool::Task & f)191 void OHOS::ThreadPool::AddTask(const OHOS::ThreadPool::Task &f)
192 {
193 BThreadPool::task->AddTask(f);
194 }
195
196 namespace OHOS::FileManagement::Backup {
197 using namespace std;
198 using namespace testing;
199 using namespace testing::ext;
200
201 const string BUNDLE_NAME = "com.example.app2backup";
202 constexpr int32_t SERVICE_ID = 5203;
203
204 class ServiceTest : public testing::Test {
205 public:
206 static void SetUpTestCase(void);
207 static void TearDownTestCase();
SetUp()208 void SetUp() {};
TearDown()209 void TearDown() {};
210
211 static inline sptr<Service> service = nullptr;
212 static inline shared_ptr<BackupParaMock> param = nullptr;
213 static inline shared_ptr<BJsonUtilMock> jsonUtil = nullptr;
214 static inline shared_ptr<SvcSessionManagerMock> session = nullptr;
215 static inline shared_ptr<BundleMgrAdapterMock> bms = nullptr;
216 static inline sptr<SvcExtensionProxyMock> svcProxy = nullptr;
217 static inline sptr<SvcBackupConnectionMock> connect = nullptr;
218 static inline shared_ptr<SABackupConnectionMock> saConnect = nullptr;
219 static inline shared_ptr<IPCSkeletonMock> skeleton = nullptr;
220 static inline sptr<ServiceReverseProxyMock> srProxy = nullptr;
221 static inline shared_ptr<BJsonClearDataConfigMock> cdConfig = nullptr;
222 static inline shared_ptr<SAUtilsMock> saUtils = nullptr;
223 static inline shared_ptr<AccessTokenKitMock> token = nullptr;
224 static inline shared_ptr<BJsonDisposalConfigMock> jdConfig = nullptr;
225 static inline shared_ptr<SystemAbilityMock> ability = nullptr;
226 static inline shared_ptr<SvcRestoreDepsManagerMock> depManager = nullptr;
227 static inline shared_ptr<NotifyWorkServiceMock> notify = nullptr;
228 static inline shared_ptr<AppGalleryDisposeProxyMock> gallery = nullptr;
229 static inline shared_ptr<StorageMgrAdapterMock> sms = nullptr;
230 static inline shared_ptr<ThreadPoolMock> task = nullptr;
231 };
232
SetUpTestCase(void)233 void ServiceTest::SetUpTestCase(void)
234 {
235 GTEST_LOG_(INFO) << "SetUpTestCase enter";
236 service = sptr(new Service(SERVICE_ID));
237 param = make_shared<BackupParaMock>();
238 BackupParaMock::backupPara = param;
239 jsonUtil = make_shared<BJsonUtilMock>();
240 BJsonUtilMock::jsonUtil = jsonUtil;
241 session = make_shared<SvcSessionManagerMock>();
242 SvcSessionManagerMock::sessionManager = session;
243 svcProxy = sptr(new SvcExtensionProxyMock());
244 bms = make_shared<BundleMgrAdapterMock>();
245 BundleMgrAdapterMock::bms = bms;
246 connect = sptr(new SvcBackupConnectionMock());
247 SvcBackupConnectionMock::connect = connect;
248 saConnect = make_shared<SABackupConnectionMock>();
249 SABackupConnectionMock::saConnect = saConnect;
250 skeleton = make_shared<IPCSkeletonMock>();
251 IPCSkeletonMock::skeleton = skeleton;
252 srProxy = sptr(new ServiceReverseProxyMock());
253 cdConfig = make_shared<BJsonClearDataConfigMock>();
254 BJsonClearDataConfigMock::config = cdConfig;
255 saUtils = make_shared<SAUtilsMock>();
256 SAUtilsMock::utils = saUtils;
257 token = make_shared<AccessTokenKitMock>();
258 AccessTokenKitMock::token = token;
259 jdConfig = make_shared<BJsonDisposalConfigMock>();
260 BJsonDisposalConfigMock::config = jdConfig;
261 ability = make_shared<SystemAbilityMock>();
262 SystemAbilityMock::ability = ability;
263 depManager = make_shared<SvcRestoreDepsManagerMock>();
264 SvcRestoreDepsManagerMock::manager = depManager;
265 notify = make_shared<NotifyWorkServiceMock>();
266 NotifyWorkServiceMock::notify = notify;
267 gallery = make_shared<AppGalleryDisposeProxyMock>();
268 AppGalleryDisposeProxyMock::proxy = gallery;
269 sms = make_shared<StorageMgrAdapterMock>();
270 StorageMgrAdapterMock::sms = sms;
271 task = make_shared<ThreadPoolMock>();
272 ThreadPoolMock::task = task;
273 }
274
TearDownTestCase()275 void ServiceTest::TearDownTestCase()
276 {
277 GTEST_LOG_(INFO) << "TearDownTestCase enter";
278 service = nullptr;
279 BackupParaMock::backupPara = nullptr;
280 param = nullptr;
281 BJsonUtilMock::jsonUtil = nullptr;
282 jsonUtil = nullptr;
283 SvcSessionManagerMock::sessionManager = nullptr;
284 session = nullptr;
285 svcProxy = nullptr;
286 BundleMgrAdapterMock::bms = nullptr;
287 bms = nullptr;
288 SvcBackupConnectionMock::connect = nullptr;
289 connect = nullptr;
290 SABackupConnectionMock::saConnect = nullptr;
291 saConnect = nullptr;
292 IPCSkeletonMock::skeleton = nullptr;
293 skeleton = nullptr;
294 srProxy = nullptr;
295 BJsonClearDataConfigMock::config = nullptr;
296 cdConfig = nullptr;
297 SAUtilsMock::utils = nullptr;
298 saUtils = nullptr;
299 AccessTokenKitMock::token = nullptr;
300 token = nullptr;
301 BJsonDisposalConfigMock::config = nullptr;
302 jdConfig = nullptr;
303 SystemAbilityMock::ability = nullptr;
304 ability = nullptr;
305 SvcRestoreDepsManagerMock::manager = nullptr;
306 depManager = nullptr;
307 NotifyWorkServiceMock::notify = nullptr;
308 notify = nullptr;
309 AppGalleryDisposeProxyMock::proxy = nullptr;
310 gallery = nullptr;
311 StorageMgrAdapterMock::sms = nullptr;
312 sms = nullptr;
313 ThreadPoolMock::task = nullptr;
314 task = nullptr;
315 }
316
317 #include "sub_service_test.cpp"
318
319 /**
320 * @tc.number: SUB_Service_GetUserIdDefault_0000
321 * @tc.name: SUB_Service_GetUserIdDefault_0000
322 * @tc.desc: 测试 GetUserIdDefault 的正常/异常分支
323 * @tc.size: MEDIUM
324 * @tc.type: FUNC
325 * @tc.level Level 1
326 * @tc.require: issueIAKC3I
327 */
328 HWTEST_F(ServiceTest, SUB_Service_GetUserIdDefault_0000, TestSize.Level1)
329 {
330 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetUserIdDefault_0000";
331 try {
332 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
333 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
334 auto ret = service->GetUserIdDefault();
335 EXPECT_EQ(ret, DEBUG_ID + 1);
336
337 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair<bool, int32_t>(false, 0)));
338 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
339 ret = service->GetUserIdDefault();
340 EXPECT_EQ(ret, BConstants::DEFAULT_USER_ID);
341
342 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair<bool, int32_t>(true, 0)));
343 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
344 ret = service->GetUserIdDefault();
345 EXPECT_EQ(ret, BConstants::DEFAULT_USER_ID);
346
347 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair<bool, int32_t>(false, 0)));
348 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::XTS_UID));
349 ret = service->GetUserIdDefault();
350 EXPECT_EQ(ret, BConstants::DEFAULT_USER_ID);
351
352 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair<bool, int32_t>(false, 0)));
353 EXPECT_CALL(*skeleton, GetCallingUid())
354 .WillOnce(Return(BConstants::SPAN_USERID_UID + BConstants::SPAN_USERID_UID));
355 ret = service->GetUserIdDefault();
356 EXPECT_EQ(ret, 2);
357 } catch (...) {
358 EXPECT_TRUE(false);
359 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetUserIdDefault.";
360 }
361 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetUserIdDefault_0000";
362 }
363
364 /**
365 * @tc.number: SUB_Service_OnStart_0100
366 * @tc.name: SUB_Service_OnStart_0100
367 * @tc.desc: 测试 OnStart
368 * @tc.size: MEDIUM
369 * @tc.type: FUNC
370 * @tc.level Level 1
371 * @tc.require: issueIAKC3I
372 */
373 HWTEST_F(ServiceTest, SUB_Service_OnStart_0100, TestSize.Level1)
374 {
375 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStart_0100";
376 try {
377 vector<string> bundleNames;
378 auto disposal = service->disposal_;
379 auto clearRecorder = service->clearRecorder_;
380 auto sched_ = service->sched_;
381 service->disposal_ = nullptr;
382 service->clearRecorder_ = nullptr;
383 service->sched_ = nullptr;
384 service->isOccupyingSession_ = false;
385
386 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
387 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames));
388 service->OnStart();
389 EXPECT_TRUE(true);
390
391 service->disposal_ = disposal;
392 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
393 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames))
394 .WillOnce(Return(bundleNames));
395 service->OnStart();
396 EXPECT_TRUE(true);
397
398 service->clearRecorder_ = clearRecorder;
399 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
400 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames))
401 .WillOnce(Return(bundleNames));
402 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(bundleNames));
403 service->OnStart();
404 EXPECT_TRUE(true);
405
406 service->sched_ = sched_;
407 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
408 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames))
409 .WillOnce(Return(bundleNames));
410 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(bundleNames));
411 service->OnStart();
412 EXPECT_TRUE(true);
413
414 service->isOccupyingSession_ = false;
415 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
416 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames))
417 .WillOnce(Return(bundleNames));
418 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(bundleNames));
419 service->OnStart();
420 EXPECT_TRUE(true);
421 } catch (...) {
422 EXPECT_TRUE(false);
423 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnStart.";
424 }
425 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnStart_0100";
426 }
427
428 /**
429 * @tc.number: SUB_Service_OnStart_0200
430 * @tc.name: SUB_Service_OnStart_0200
431 * @tc.desc: 测试 OnStart
432 * @tc.size: MEDIUM
433 * @tc.type: FUNC
434 * @tc.level Level 1
435 * @tc.require: issueIAKC3I
436 */
437 HWTEST_F(ServiceTest, SUB_Service_OnStart_0200, TestSize.Level1)
438 {
439 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStart_0200";
440 try {
441 service->isOccupyingSession_ = true;
442 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
443 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector<string>()))
444 .WillOnce(Return(vector<string>()));
445 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector<string>()));
446 service->OnStart();
447 EXPECT_TRUE(true);
448
449 service->isOccupyingSession_ = false;
450 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
451 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector<string>(1)))
452 .WillOnce(Return(vector<string>()));
453 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector<string>()));
454 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
455 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
456 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
457 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
458 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
459 service->OnStart();
460 EXPECT_TRUE(true);
461 } catch (...) {
462 EXPECT_TRUE(false);
463 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnStart.";
464 }
465 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnStart_0200";
466 }
467
468 /**
469 * @tc.number: SUB_Service_OnStart_0300
470 * @tc.name: SUB_Service_OnStart_0300
471 * @tc.desc: 测试 OnStart
472 * @tc.size: MEDIUM
473 * @tc.type: FUNC
474 * @tc.level Level 1
475 * @tc.require: issueIAKC3I
476 */
477 HWTEST_F(ServiceTest, SUB_Service_OnStart_0300, TestSize.Level1)
478 {
479 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStart_0300";
480 try {
481 auto session_ = service->session_;
482 service->session_ = nullptr;
483 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
484 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector<string>()))
485 .WillOnce(Return(vector<string>()));
486 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector<string>(1)));
487 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
488 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
489 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
490 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
491 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
492 service->OnStart();
493 EXPECT_TRUE(true);
494
495 EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false));
496 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector<string>(1)))
497 .WillOnce(Return(vector<string>()));
498 EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector<string>(1)));
499 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
500 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
501 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
502 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
503 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
504 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
505 service->OnStart();
506 service->session_ = session_;
507 EXPECT_TRUE(true);
508 } catch (...) {
509 EXPECT_TRUE(false);
510 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnStart.";
511 }
512 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnStart_0300";
513 }
514
515 /**
516 * @tc.number: SUB_Service_GetLocalCapabilities_0100
517 * @tc.name: SUB_Service_GetLocalCapabilities_0100
518 * @tc.desc: 测试 GetLocalCapabilities
519 * @tc.size: MEDIUM
520 * @tc.type: FUNC
521 * @tc.level Level 1
522 * @tc.require: issueIAKC3I
523 */
524 HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilities_0100, TestSize.Level1)
525 {
526 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilities_0100";
527 try {
528 ASSERT_TRUE(service != nullptr);
529 service->session_ = nullptr;
530 UniqueFd fd = service->GetLocalCapabilities();
531 EXPECT_NE(fd, BError(BError::Codes::OK));
532
533 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
534 service->isOccupyingSession_.store(true);
535 fd = service->GetLocalCapabilities();
536 EXPECT_NE(fd, BError(BError::Codes::OK));
537 service->isOccupyingSession_.store(false);
538 } catch (...) {
539 EXPECT_TRUE(false);
540 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetLocalCapabilities.";
541 }
542 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetLocalCapabilities_0100";
543 }
544
545 /**
546 * @tc.number: SUB_Service_VerifyCallerAndGetCallerName_0100
547 * @tc.name: SUB_Service_VerifyCallerAndGetCallerName_0100
548 * @tc.desc: 测试 VerifyCallerAndGetCallerName
549 * @tc.size: MEDIUM
550 * @tc.type: FUNC
551 * @tc.level Level 1
552 * @tc.require: issueIAKC3I
553 */
554 HWTEST_F(ServiceTest, SUB_Service_VerifyCallerAndGetCallerName_0100, TestSize.Level1)
555 {
556 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_VerifyCallerAndGetCallerName_0100";
557 try {
558 ASSERT_TRUE(service != nullptr);
559 std::string bundleName = "";
560 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
561 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
562 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(-1));
563 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
564 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
565 auto ret = service->VerifyCallerAndGetCallerName(bundleName);
566 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
567
568 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
569 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
570 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
571 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
572 ret = service->VerifyCallerAndGetCallerName(bundleName);
573 EXPECT_TRUE(bundleName.empty());
574
575 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
576 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
577 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
578 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
579 ret = service->VerifyCallerAndGetCallerName(bundleName);
580 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
581 } catch (...) {
582 EXPECT_TRUE(false);
583 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by VerifyCallerAndGetCallerName.";
584 }
585 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_VerifyCallerAndGetCallerName_0100";
586 }
587
588 /**
589 * @tc.number: SUB_Service_VerifyCaller_0100
590 * @tc.name: SUB_Service_VerifyCaller_0100
591 * @tc.desc: 测试 VerifyCaller
592 * @tc.size: MEDIUM
593 * @tc.type: FUNC
594 * @tc.level Level 1
595 * @tc.require: issueIAKC3I
596 */
597 HWTEST_F(ServiceTest, SUB_Service_VerifyCaller_0100, TestSize.Level1)
598 {
599 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_VerifyCaller_0100";
600 ASSERT_TRUE(service != nullptr);
601 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
602 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
603 EXPECT_CALL(*token, VerifyAccessToken(_, _))
604 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
605 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
606 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
607 ErrCode ret = service->VerifyCaller();
608 EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
609
610 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
611 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
612 EXPECT_CALL(*token, VerifyAccessToken(_, _))
613 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
614 ret = service->VerifyCaller();
615 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
616
617 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
618 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
619 EXPECT_CALL(*token, VerifyAccessToken(_, _))
620 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
621 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
622 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
623 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
624 ret = service->VerifyCaller();
625 EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
626
627 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
628 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
629 EXPECT_CALL(*token, VerifyAccessToken(_, _))
630 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
631 EXPECT_CALL(*token, IsSystemAppByFullTokenID(_)).WillOnce(Return(false));
632 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
633 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
634 ret = service->VerifyCaller();
635 EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
636
637 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
638 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
639 EXPECT_CALL(*token, VerifyAccessToken(_, _))
640 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
641 EXPECT_CALL(*token, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
642 ret = service->VerifyCaller();
643 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
644 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_VerifyCaller_0100";
645 }
646
647 /**
648 * @tc.number: SUB_Service_VerifyCaller_0200
649 * @tc.name: SUB_Service_VerifyCaller_0200
650 * @tc.desc: 测试 VerifyCaller
651 * @tc.size: MEDIUM
652 * @tc.type: FUNC
653 * @tc.level Level 1
654 * @tc.require: issueIAKC3I
655 */
656 HWTEST_F(ServiceTest, SUB_Service_VerifyCaller_0200, TestSize.Level1)
657 {
658 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_VerifyCaller_0200";
659 try {
660 ASSERT_TRUE(service != nullptr);
661 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
662 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
663 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::XTS_UID));
664 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
665 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
666 ErrCode ret = service->VerifyCaller();
667 EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
668
669 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
670 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
671 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
672 ret = service->VerifyCaller();
673 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
674
675 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
676 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_INVALID));
677 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
678 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
679 ret = service->VerifyCaller();
680 EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
681 } catch (...) {
682 EXPECT_TRUE(false);
683 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by VerifyCaller.";
684 }
685 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_VerifyCaller_0200";
686 }
687
688 /**
689 * @tc.number: SUB_Service_SpecialVersion_0200
690 * @tc.name: SUB_Service_SpecialVersion_0200
691 * @tc.desc: 测试 SpecialVersion
692 * @tc.size: MEDIUM
693 * @tc.type: FUNC
694 * @tc.level Level 1
695 * @tc.require: issueIAKC3I
696 */
697 HWTEST_F(ServiceTest, SUB_Service_SpecialVersion_0200, TestSize.Level1)
698 {
699 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SpecialVersion_0200";
700 try {
701 string versionName(BConstants::DEFAULT_VERSION_NAME);
702 auto ret = SpecialVersion(versionName);
703 EXPECT_TRUE(ret);
704
705 versionName.clear();
706 ret = SpecialVersion(versionName);
707 EXPECT_FALSE(ret);
708 } catch (...) {
709 EXPECT_TRUE(false);
710 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SpecialVersion.";
711 }
712 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SpecialVersion_0200";
713 }
714
715 /**
716 * @tc.number: SUB_Service_OnBundleStarted_0100
717 * @tc.name: SUB_Service_OnBundleStarted_0100
718 * @tc.desc: 测试 OnBundleStarted
719 * @tc.size: MEDIUM
720 * @tc.type: FUNC
721 * @tc.level Level 1
722 * @tc.require: issueIAKC3I
723 */
724 HWTEST_F(ServiceTest, SUB_Service_OnBundleStarted_0100, TestSize.Level1)
725 {
726 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnBundleStarted_0100";
727 try {
728 BError error(BError::Codes::OK);
729 sptr<SvcSessionManager> session_ = service->session_;
730 BundleName bundleName;
731 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
732 service->OnBundleStarted(error, session_, bundleName);
733 EXPECT_TRUE(true);
734
735 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
736 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false));
737 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
738 EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0));
739 service->OnBundleStarted(error, session_, bundleName);
740 EXPECT_TRUE(true);
741
742 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
743 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
744 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false));
745 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
746 EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0));
747 service->OnBundleStarted(error, session_, bundleName);
748 EXPECT_TRUE(true);
749
750 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
751 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
752 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
753 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
754 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0));
755 service->OnBundleStarted(error, session_, bundleName);
756 EXPECT_TRUE(true);
757 } catch (...) {
758 EXPECT_TRUE(false);
759 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnBundleStarted.";
760 }
761 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnBundleStarted_0100";
762 }
763
764 /**
765 * @tc.number: SUB_Service_GetRestoreBundleNames_0100
766 * @tc.name: SUB_Service_GetRestoreBundleNames_0100
767 * @tc.desc: 测试 GetRestoreBundleNames
768 * @tc.size: MEDIUM
769 * @tc.type: FUNC
770 * @tc.level Level 1
771 * @tc.require: issueIAKC3I
772 */
773 HWTEST_F(ServiceTest, SUB_Service_GetRestoreBundleNames_0100, TestSize.Level1)
774 {
775 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetRestoreBundleNames_0100";
776 try {
777 vector<BundleName> bundleNames;
778 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
779 std::string backupVersion;
780 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
781 EXPECT_CALL(*bms, GetBundleInfos(_, _)).WillOnce(Return(bundleInfos));
782 EXPECT_THROW(service->GetRestoreBundleNames(UniqueFd(-1), service->session_, bundleNames, backupVersion),
783 BError);
784 } catch (...) {
785 EXPECT_TRUE(false);
786 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetRestoreBundleNames.";
787 }
788 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetRestoreBundleNames_0100";
789 }
790
791 /**
792 * @tc.number: SUB_Service_HandleExceptionOnAppendBundles_0100
793 * @tc.name: SUB_Service_HandleExceptionOnAppendBundles_0100
794 * @tc.desc: 测试 HandleExceptionOnAppendBundles
795 * @tc.size: MEDIUM
796 * @tc.type: FUNC
797 * @tc.level Level 1
798 * @tc.require: issueIAKC3I
799 */
800 HWTEST_F(ServiceTest, SUB_Service_HandleExceptionOnAppendBundles_0100, TestSize.Level1)
801 {
802 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExceptionOnAppendBundles_0100";
803 try {
804 vector<BundleName> appendBundleNames { "bundleName" };
805 vector<BundleName> restoreBundleNames;
806 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
807 service->HandleExceptionOnAppendBundles(service->session_, appendBundleNames, restoreBundleNames);
808 EXPECT_TRUE(true);
809
810 restoreBundleNames.emplace_back("bundleName");
811 restoreBundleNames.emplace_back("bundleName2");
812 service->HandleExceptionOnAppendBundles(service->session_, appendBundleNames, restoreBundleNames);
813 EXPECT_TRUE(true);
814 } catch (...) {
815 EXPECT_TRUE(false);
816 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExceptionOnAppendBundles.";
817 }
818 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExceptionOnAppendBundles_0100";
819 }
820
821 /**
822 * @tc.number: SUB_Service_AppendBundlesRestoreSession_0100
823 * @tc.name: SUB_Service_AppendBundlesRestoreSession_0100
824 * @tc.desc: 测试 AppendBundlesRestoreSession
825 * @tc.size: MEDIUM
826 * @tc.type: FUNC
827 * @tc.level Level 1
828 * @tc.require: issueIAKC3I
829 */
830 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesRestoreSession_0100, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesRestoreSession_0100";
833 try {
834 ASSERT_TRUE(service != nullptr);
835 std::vector<BundleName> bundleNames;
836 std::vector<std::string> bundleInfos;
837 RestoreTypeEnum restoreType = RESTORE_DATA_READDY;
838 int32_t userId = 100;
839
840 service->session_ = nullptr;
841 auto ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, bundleInfos, restoreType, userId);
842 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
843
844 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
845 service->isOccupyingSession_.store(true);
846 ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, bundleInfos, restoreType, userId);
847 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
848 } catch (...) {
849 EXPECT_TRUE(false);
850 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesRestoreSession.";
851 }
852 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesRestoreSession_0100";
853 }
854
855 /**
856 * @tc.number: SUB_Service_AppendBundlesRestoreSession_0200
857 * @tc.name: SUB_Service_AppendBundlesRestoreSession_0200
858 * @tc.desc: 测试 AppendBundlesRestoreSession
859 * @tc.size: MEDIUM
860 * @tc.type: FUNC
861 * @tc.level Level 1
862 * @tc.require: issueIAKC3I
863 */
864 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesRestoreSession_0200, TestSize.Level1)
865 {
866 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesRestoreSession_0200";
867 try {
868 ASSERT_TRUE(service != nullptr);
869 vector<string> bundleInfos;
870 vector<BundleName> bundleNames;
871 vector<BJsonEntityCaps::BundleInfo> infos;
872 RestoreTypeEnum restoreType = RESTORE_DATA_READDY;
873 int32_t userId = DEFAULT_INVAL_VALUE;
874 map<string, vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap;
875 service->isOccupyingSession_.store(false);
876 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
877 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
878 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
879 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0));
880 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
881 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
882 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
883 EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap));
884 EXPECT_CALL(*bms, GetBundleInfos(_, _)).WillOnce(Return(infos));
885 auto ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, bundleInfos, restoreType, userId);
886 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
887 } catch (...) {
888 EXPECT_TRUE(false);
889 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesRestoreSession.";
890 }
891 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesRestoreSession_0200";
892 }
893
894 /**
895 * @tc.number: SUB_Service_AppendBundlesRestoreSession_0300
896 * @tc.name: SUB_Service_AppendBundlesRestoreSession_0300
897 * @tc.desc: 测试 AppendBundlesRestoreSession
898 * @tc.size: MEDIUM
899 * @tc.type: FUNC
900 * @tc.level Level 1
901 * @tc.require: issueIAKC3I
902 */
903 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesRestoreSession_0300, TestSize.Level1)
904 {
905 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesRestoreSession_0300";
906 try {
907 ASSERT_TRUE(service != nullptr);
908 std::vector<BundleName> bundleNames;
909 RestoreTypeEnum restoreType = RESTORE_DATA_READDY;
910 int32_t userId = 100;
911
912 service->session_ = nullptr;
913 auto ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, restoreType, userId);
914 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
915
916 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
917 service->isOccupyingSession_.store(true);
918 ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, restoreType, userId);
919 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
920 } catch (...) {
921 EXPECT_TRUE(false);
922 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesRestoreSession.";
923 }
924 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesRestoreSession_0300";
925 }
926
927 /**
928 * @tc.number: SUB_Service_SetCurrentSessProperties_0100
929 * @tc.name: SUB_Service_SetCurrentSessProperties_0100
930 * @tc.desc: 测试 SetCurrentSessProperties
931 * @tc.size: MEDIUM
932 * @tc.type: FUNC
933 * @tc.level Level 1
934 * @tc.require: issueIAKC3I
935 */
936 HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0100, TestSize.Level1)
937 {
938 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SetCurrentSessProperties_0100";
939 try {
940 ASSERT_TRUE(service != nullptr);
941 BJsonEntityCaps::BundleInfo info;
942 map<string, bool> isClearDataFlags;
943 string bundleNameIndexInfo;
944
945 service->session_ = nullptr;
946 service->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo);
947 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
948 service->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo);
949
950 info = BJsonEntityCaps::BundleInfo {BUNDLE_NAME, 0, {}, {}, 0, 0, true, false, false, BUNDLE_NAME};
951 isClearDataFlags = {{BUNDLE_NAME, true}};
952 service->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo);
953 } catch (...) {
954 EXPECT_TRUE(false);
955 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetCurrentSessProperties.";
956 }
957 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SetCurrentSessProperties_0100";
958 }
959
960 /**
961 * @tc.number: SUB_Service_SetCurrentSessProperties_0200
962 * @tc.name: SUB_Service_SetCurrentSessProperties_0200
963 * @tc.desc: 测试 SetCurrentSessProperties
964 * @tc.size: MEDIUM
965 * @tc.type: FUNC
966 * @tc.level Level 1
967 * @tc.require: issueIAKC3I
968 */
969 HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0200, TestSize.Level1)
970 {
971 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SetCurrentSessProperties_0200";
972 try {
973 ASSERT_TRUE(service != nullptr);
974 vector<BJsonEntityCaps::BundleInfo> restoreBundleInfos = {
975 {.name = "bundleName", .appIndex = 0, .allToBackup = false, .versionName = ""} };
976 vector<string> restoreBundleNames;
977 map<string, vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap;
978 map<string, bool> isClearDataFlags;
979 RestoreTypeEnum restoreType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND;
980 std::string backupVersion;
981 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
982 isClearDataFlags, restoreType, backupVersion);
983
984 restoreBundleNames.emplace_back("bundleName");
985 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
986 .WillOnce(Return("bundleName"));
987 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
988 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
989 isClearDataFlags, restoreType, backupVersion);
990 EXPECT_TRUE(true);
991
992 restoreBundleInfos[0].allToBackup = true;
993 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
994 .WillOnce(Return("bundleName"));
995 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
996 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
997 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
998 isClearDataFlags, restoreType, backupVersion);
999 EXPECT_TRUE(true);
1000
1001 restoreBundleInfos[0].allToBackup = false;
1002 restoreBundleInfos[0].versionName = string(BConstants::DEFAULT_VERSION_NAME);
1003 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1004 .WillOnce(Return("bundleName"));
1005 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1006 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
1007 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
1008 isClearDataFlags, restoreType, backupVersion);
1009 EXPECT_TRUE(true);
1010 } catch (...) {
1011 EXPECT_TRUE(false);
1012 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetCurrentSessProperties.";
1013 }
1014 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SetCurrentSessProperties_0200";
1015 }
1016
1017 /**
1018 * @tc.number: SUB_Service_SetCurrentSessProperties_0300
1019 * @tc.name: SUB_Service_SetCurrentSessProperties_0300
1020 * @tc.desc: 测试 SetCurrentSessProperties
1021 * @tc.size: MEDIUM
1022 * @tc.type: FUNC
1023 * @tc.level Level 1
1024 * @tc.require: issueIAKC3I
1025 */
1026 HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0300, TestSize.Level1)
1027 {
1028 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SetCurrentSessProperties_0300";
1029 try {
1030 ASSERT_TRUE(service != nullptr);
1031 vector<BJsonEntityCaps::BundleInfo> restoreBundleInfos = {
1032 {.name = "bundleName", .appIndex = 0, .allToBackup = true, .extensionName = ""} };
1033 vector<string> restoreBundleNames { "bundleName" };
1034 map<string, vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap;
1035 map<string, bool> isClearDataFlags;
1036 RestoreTypeEnum restoreType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND;
1037 std::string backupVersion;
1038
1039 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0))
1040 .WillOnce(Return(0)).WillOnce(Return(0));
1041 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1042 .WillOnce(Return("bundleName"));
1043 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
1044 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)).WillOnce(Return(false));
1045 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
1046 isClearDataFlags, restoreType, backupVersion);
1047 EXPECT_TRUE(true);
1048
1049 restoreBundleInfos[0].extensionName = "extensionName";
1050 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1051 .WillOnce(Return("bundleName"));
1052 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)).WillOnce(Return(false));
1053 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
1054 isClearDataFlags, restoreType, backupVersion);
1055 EXPECT_TRUE(true);
1056
1057 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1058 .WillOnce(Return("bundleName"));
1059 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)).WillOnce(Return(false));
1060 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
1061 isClearDataFlags, restoreType, backupVersion);
1062
1063 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1064 .WillOnce(Return("bundleName"));
1065 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(true)).WillOnce(Return(false));
1066 EXPECT_CALL(*notify, NotifyBundleDetail(_)).WillOnce(Return(true));
1067 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
1068 isClearDataFlags, restoreType, backupVersion);
1069
1070 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1071 .WillOnce(Return("bundleName"));
1072 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)).WillOnce(Return(true));
1073 service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap,
1074 isClearDataFlags, restoreType, backupVersion);
1075 EXPECT_TRUE(true);
1076 } catch (...) {
1077 EXPECT_TRUE(false);
1078 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetCurrentSessProperties.";
1079 }
1080 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SetCurrentSessProperties_0300";
1081 }
1082
1083 /**
1084 * @tc.number: SUB_Service_AppendBundlesBackupSession_0100
1085 * @tc.name: SUB_Service_AppendBundlesBackupSession_0100
1086 * @tc.desc: 测试 AppendBundlesBackupSession
1087 * @tc.size: MEDIUM
1088 * @tc.type: FUNC
1089 * @tc.level Level 1
1090 * @tc.require: issueIAKC3I
1091 */
1092 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesBackupSession_0100, TestSize.Level1)
1093 {
1094 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesBackupSession_0100";
1095 try {
1096 ASSERT_TRUE(service != nullptr);
1097 std::vector<BundleName> bundleNames;
1098
1099 service->session_ = nullptr;
1100 auto ret = service->AppendBundlesBackupSession(bundleNames);
1101 EXPECT_NE(ret, BError(BError::Codes::OK));
1102
1103 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
1104 service->isOccupyingSession_.store(true);
1105 ret = service->AppendBundlesBackupSession(bundleNames);
1106 EXPECT_NE(ret, BError(BError::Codes::OK));
1107 } catch (...) {
1108 EXPECT_TRUE(false);
1109 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesBackupSession.";
1110 }
1111 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesBackupSession_0100";
1112 }
1113
1114 /**
1115 * @tc.number: SUB_Service_AppendBundlesBackupSession_0200
1116 * @tc.name: SUB_Service_AppendBundlesBackupSession_0200
1117 * @tc.desc: 测试 AppendBundlesBackupSession
1118 * @tc.size: MEDIUM
1119 * @tc.type: FUNC
1120 * @tc.level Level 1
1121 * @tc.require: issueIAKC3I
1122 */
1123 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesBackupSession_0200, TestSize.Level1)
1124 {
1125 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesBackupSession_0200";
1126 try {
1127 ASSERT_TRUE(service != nullptr);
1128 vector<BundleName> bundleNames;
1129 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
1130 service->isOccupyingSession_.store(false);
1131 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0));
1132 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1133 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1134 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
1135 EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos));
1136 EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false));
1137 auto ret = service->AppendBundlesBackupSession(bundleNames);
1138 EXPECT_EQ(ret, BError(BError::Codes::OK));
1139 } catch (...) {
1140 EXPECT_TRUE(false);
1141 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesBackupSession.";
1142 }
1143 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesBackupSession_0200";
1144 }
1145
1146
1147 /**
1148 * @tc.number: SUB_Service_AppendBundlesDetailsBackupSession_0100
1149 * @tc.name: SUB_Service_AppendBundlesDetailsBackupSession_0100
1150 * @tc.desc: 测试 AppendBundlesDetailsBackupSession
1151 * @tc.size: MEDIUM
1152 * @tc.type: FUNC
1153 * @tc.level Level 1
1154 * @tc.require: issueIAKC3I
1155 */
1156 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesDetailsBackupSession_0100, TestSize.Level1)
1157 {
1158 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesDetailsBackupSession_0100";
1159 try {
1160 ASSERT_TRUE(service != nullptr);
1161 std::vector<BundleName> bundleNames;
1162 std::vector<std::string> bundleInfos;
1163
1164 service->session_ = nullptr;
1165 auto ret = service->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos);
1166 EXPECT_NE(ret, BError(BError::Codes::OK));
1167
1168 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
1169 service->isOccupyingSession_.store(true);
1170 ret = service->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos);
1171 EXPECT_NE(ret, BError(BError::Codes::OK));
1172 service->isOccupyingSession_.store(false);
1173 } catch (...) {
1174 EXPECT_TRUE(false);
1175 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesDetailsBackupSession.";
1176 }
1177 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesDetailsBackupSession_0100";
1178 }
1179
1180 /**
1181 * @tc.number: SUB_Service_AppendBundlesDetailsBackupSession_0200
1182 * @tc.name: SUB_Service_AppendBundlesDetailsBackupSession_0200
1183 * @tc.desc: 测试 AppendBundlesDetailsBackupSession
1184 * @tc.size: MEDIUM
1185 * @tc.type: FUNC
1186 * @tc.level Level 1
1187 * @tc.require: issueIAKC3I
1188 */
1189 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesDetailsBackupSession_0200, TestSize.Level1)
1190 {
1191 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesDetailsBackupSession_0200";
1192 try {
1193 ASSERT_TRUE(service != nullptr);
1194 vector<BundleName> bundleNames;
1195 vector<string> bundleInfos;
1196 vector<BJsonEntityCaps::BundleInfo> infos;
1197 map<string, vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap;
1198 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0));
1199 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1200 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1201 EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap));
1202 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
1203 EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(infos));
1204 EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false));
1205 auto ret = service->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos);
1206 EXPECT_EQ(ret, BError(BError::Codes::OK));
1207 } catch (...) {
1208 EXPECT_TRUE(false);
1209 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesDetailsBackupSession.";
1210 }
1211 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesDetailsBackupSession_0200";
1212 }
1213
1214 /**
1215 * @tc.number: SUB_Service_PublishFile_0100
1216 * @tc.name: SUB_Service_PublishFile_0100
1217 * @tc.desc: 测试 PublishFile
1218 * @tc.size: MEDIUM
1219 * @tc.type: FUNC
1220 * @tc.level Level 1
1221 * @tc.require: issueIAKC3I
1222 */
1223 HWTEST_F(ServiceTest, SUB_Service_PublishFile_0100, TestSize.Level1)
1224 {
1225 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_PublishFile_0100";
1226 try {
1227 ASSERT_TRUE(service != nullptr);
1228 BFileInfo fileInfo {BUNDLE_NAME, "", 0};
1229
1230 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0));
1231 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1232 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1233 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1234 auto ret = service->PublishFile(fileInfo);
1235 EXPECT_NE(ret, BError(BError::Codes::OK));
1236
1237 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0));
1238 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1239 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1240 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1241 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1242 ret = service->PublishFile(fileInfo);
1243 EXPECT_NE(ret, BError(BError::Codes::OK));
1244
1245 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0));
1246 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1247 EXPECT_CALL(*skeleton, GetCallingUid()).WillRepeatedly(Return(BConstants::SYSTEM_UID));
1248 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1249 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1250 EXPECT_CALL(*svcProxy, PublishFile(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1251 ret = service->PublishFile(fileInfo);
1252 EXPECT_NE(ret, BError(BError::Codes::OK));
1253 } catch (...) {
1254 EXPECT_TRUE(false);
1255 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by PublishFile.";
1256 }
1257 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_PublishFile_0100";
1258 }
1259
1260 /**
1261 * @tc.number: SUB_Service_AppDone_0100
1262 * @tc.name: SUB_Service_AppDone_0100
1263 * @tc.desc: 测试 AppDone
1264 * @tc.size: MEDIUM
1265 * @tc.type: FUNC
1266 * @tc.level Level 1
1267 * @tc.require: issueIAKC3I
1268 */
1269 HWTEST_F(ServiceTest, SUB_Service_AppDone_0100, TestSize.Level1)
1270 {
1271 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppDone_0100";
1272 try {
1273 ASSERT_TRUE(service != nullptr);
1274 ErrCode errCode = BError(BError::Codes::OK).GetCode();
1275
1276 service->session_ = nullptr;
1277 auto ret = service->AppDone(errCode);
1278 EXPECT_NE(ret, BError(BError::Codes::OK));
1279 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
1280
1281 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1282 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
1283 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1284 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1285 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1286 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false));
1287 ret = service->AppDone(errCode);
1288 EXPECT_EQ(ret, BError(BError::Codes::OK));
1289 } catch (...) {
1290 EXPECT_TRUE(false);
1291 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppDone.";
1292 }
1293 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppDone_0100";
1294 }
1295
1296 /**
1297 * @tc.number: SUB_Service_AppDone_0200
1298 * @tc.name: SUB_Service_AppDone_0200
1299 * @tc.desc: 测试 AppDone
1300 * @tc.size: MEDIUM
1301 * @tc.type: FUNC
1302 * @tc.level Level 1
1303 * @tc.require: issueIAKC3I
1304 */
1305 HWTEST_F(ServiceTest, SUB_Service_AppDone_0200, TestSize.Level1)
1306 {
1307 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppDone_0200";
1308 try {
1309 ASSERT_TRUE(service != nullptr);
1310 ErrCode errCode = BError(BError::Codes::SA_INVAL_ARG).GetCode();
1311
1312 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1313 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
1314 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1315 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1316 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1317 auto ret = service->AppDone(errCode);
1318 EXPECT_EQ(ret, BError(BError::Codes::OK));
1319
1320
1321 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1322 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
1323 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1324 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1325 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1326 ret = service->AppDone(errCode);
1327 EXPECT_EQ(ret, BError(BError::Codes::OK));
1328 } catch (...) {
1329 EXPECT_TRUE(false);
1330 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppDone.";
1331 }
1332 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppDone_0200";
1333 }
1334
1335 /**
1336 * @tc.number: SUB_Service_HandleCurBundleEndWork_0100
1337 * @tc.name: SUB_Service_HandleCurBundleEndWork_0100
1338 * @tc.desc: 测试 HandleCurBundleEndWork
1339 * @tc.size: MEDIUM
1340 * @tc.type: FUNC
1341 * @tc.level Level 1
1342 * @tc.require: issueIAKC3I
1343 */
1344 HWTEST_F(ServiceTest, SUB_Service_HandleCurBundleEndWork_0100, TestSize.Level1)
1345 {
1346 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleCurBundleEndWork_0100";
1347 try {
1348 ASSERT_TRUE(service != nullptr);
1349 std::string bundleName = BUNDLE_NAME;
1350 BackupRestoreScenario senario = BackupRestoreScenario::INCREMENTAL_BACKUP;
1351 service->HandleCurBundleEndWork(bundleName, senario);
1352 EXPECT_TRUE(true);
1353
1354 senario = BackupRestoreScenario::FULL_RESTORE;
1355 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1356 service->HandleCurBundleEndWork(bundleName, senario);
1357 EXPECT_TRUE(true);
1358
1359 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1360 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1361 service->HandleCurBundleEndWork(bundleName, senario);
1362 EXPECT_TRUE(true);
1363
1364 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1365 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1366 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1367 service->HandleCurBundleEndWork(bundleName, senario);
1368 EXPECT_TRUE(true);
1369 } catch (...) {
1370 EXPECT_TRUE(false);
1371 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleCurBundleEndWork.";
1372 }
1373 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleCurBundleEndWork_0100";
1374 }
1375
1376 /**
1377 * @tc.number: SUB_Service_LaunchBackupExtension_0100
1378 * @tc.name: SUB_Service_LaunchBackupExtension_0100
1379 * @tc.desc: 测试 LaunchBackupExtension
1380 * @tc.size: MEDIUM
1381 * @tc.type: FUNC
1382 * @tc.level Level 1
1383 * @tc.require: issueIAKC3I
1384 */
1385 HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, TestSize.Level1)
1386 {
1387 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupExtension_0100";
1388 try {
1389 ASSERT_TRUE(service != nullptr);
1390 std::string bundleName = "";
1391 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1392 EXPECT_CALL(*session, UpdateDfxInfo(_, _)).WillOnce(Return());
1393 auto ret = service->LaunchBackupExtension(bundleName);
1394 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
1395
1396 BJsonUtil::BundleDetailInfo info;
1397 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1398 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
1399 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
1400 EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return(""));
1401 EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return(""));
1402 EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0));
1403 EXPECT_CALL(*session, GetBundleRestoreType(_)).WillOnce(Return(RestoreTypeEnum::RESTORE_DATA_READDY));
1404 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return(""));
1405 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1406 ret = service->LaunchBackupExtension(bundleName);
1407 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
1408
1409 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1410 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
1411 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
1412 EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return(""));
1413 EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return(""));
1414 EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0));
1415 EXPECT_CALL(*session, GetBundleRestoreType(_)).WillOnce(Return(RestoreTypeEnum::RESTORE_DATA_READDY));
1416 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return(""));
1417 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1418 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
1419 EXPECT_CALL(*connect, WaitDisconnectDone()).WillOnce(Return(false));
1420 ret = service->LaunchBackupExtension(bundleName);
1421 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG));
1422 } catch (...) {
1423 EXPECT_TRUE(false);
1424 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by LaunchBackupExtension.";
1425 }
1426 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_LaunchBackupExtension_0100";
1427 }
1428
1429 /**
1430 * @tc.number: SUB_Service_LaunchBackupExtension_0200
1431 * @tc.name: SUB_Service_LaunchBackupExtension_0100
1432 * @tc.desc: 测试 LaunchBackupExtension
1433 * @tc.size: MEDIUM
1434 * @tc.type: FUNC
1435 * @tc.level Level 1
1436 * @tc.require: issueIAKC3I
1437 */
1438 HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0200, TestSize.Level1)
1439 {
1440 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupExtension_0200";
1441 try {
1442 ASSERT_TRUE(service != nullptr);
1443 string bundleName = "";
1444 BJsonUtil::BundleDetailInfo info;
1445 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1446 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
1447 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
1448 EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return(""));
1449 EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return(""));
1450 EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0));
1451 EXPECT_CALL(*session, GetBundleRestoreType(_)).WillOnce(Return(RestoreTypeEnum::RESTORE_DATA_READDY));
1452 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return(""));
1453 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1454 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(false));
1455 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START));
1456 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
1457 EXPECT_CALL(*session, UpdateDfxInfo(_, _)).WillOnce(Return());
1458 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _))
1459 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1460 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1461 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
1462 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
1463 auto ret = service->LaunchBackupExtension(bundleName);
1464 EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL));
1465
1466 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1467 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
1468 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
1469 EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return(""));
1470 EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return(""));
1471 EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0));
1472 EXPECT_CALL(*session, GetBundleRestoreType(_)).WillOnce(Return(RestoreTypeEnum::RESTORE_DATA_READDY));
1473 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return(""));
1474 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1475 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
1476 EXPECT_CALL(*connect, WaitDisconnectDone()).WillOnce(Return(true));
1477 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START));
1478 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
1479 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _))
1480 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1481 ret = service->LaunchBackupExtension(bundleName);
1482 EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL));
1483 } catch (...) {
1484 EXPECT_TRUE(false);
1485 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by LaunchBackupExtension.";
1486 }
1487 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_LaunchBackupExtension_0200";
1488 }
1489
1490 /**
1491 * @tc.number: SUB_Service_ClearResidualBundleData_0100
1492 * @tc.name: SUB_Service_ClearResidualBundleData_0100
1493 * @tc.desc: 测试 ClearResidualBundleData
1494 * @tc.size: MEDIUM
1495 * @tc.type: FUNC
1496 * @tc.level Level 1
1497 * @tc.require: issueIAKC3I
1498 */
1499 HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0100, TestSize.Level1)
1500 {
1501 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ClearResidualBundleData_0100";
1502 try {
1503 ASSERT_TRUE(service != nullptr);
1504 std::string bundleName = BUNDLE_NAME;
1505 service->session_ = nullptr;
1506 service->ClearResidualBundleData(bundleName);
1507 service->session_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(service)));
1508
1509 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1510 ErrCode ret = service->ClearResidualBundleData(bundleName);
1511 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1512
1513 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1514 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1515 ret = service->ClearResidualBundleData(bundleName);
1516 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1517 } catch (...) {
1518 EXPECT_TRUE(false);
1519 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ClearResidualBundleData.";
1520 }
1521 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ClearResidualBundleData_0100";
1522 }
1523
1524 /**
1525 * @tc.number: SUB_Service_AppendBundlesClearSession_0000
1526 * @tc.name: SUB_Service_AppendBundlesClearSession_0000
1527 * @tc.desc: 测试 AppendBundlesClearSession 的正常/异常分支
1528 * @tc.size: MEDIUM
1529 * @tc.type: FUNC
1530 * @tc.level Level 1
1531 * @tc.require: issueIAKC3I
1532 */
1533 HWTEST_F(ServiceTest, SUB_Service_AppendBundlesClearSession_0000, TestSize.Level1)
1534 {
1535 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesClearSession_0000";
1536 try {
1537 auto session_ = service->session_;
1538 service->session_ = nullptr;
1539 auto ret = service->AppendBundlesClearSession({ "bundleNames" });
1540 service->session_ = session_;
1541 EXPECT_EQ(ret, EPERM);
1542
1543 ret = service->AppendBundlesClearSession({});
1544 EXPECT_EQ(ret, EPERM);
1545
1546 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
1547 BJsonEntityCaps::BundleInfo info;
1548 info.name = "bundleNames";
1549 info.appIndex = 0;
1550 bundleInfos.push_back(info);
1551 EXPECT_CALL(*session, GetSessionUserId()).WillRepeatedly(Return(0));
1552 EXPECT_CALL(*bms, GetBundleInfos(_, _)).WillOnce(Return(bundleInfos));
1553 EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false));
1554 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"))
1555 .WillOnce(Return("bundleName"));
1556 ret = service->AppendBundlesClearSession({ "bundleNames" });
1557 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1558 } catch (...) {
1559 EXPECT_TRUE(false);
1560 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesClearSession.";
1561 }
1562 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AppendBundlesClearSession_0000";
1563 }
1564
1565 /**
1566 * @tc.number: SUB_Service_UpdateTimer_0000
1567 * @tc.name: SUB_Service_UpdateTimer_0000
1568 * @tc.desc: 测试 UpdateTimer 的正常/异常分支
1569 * @tc.size: MEDIUM
1570 * @tc.type: FUNC
1571 * @tc.level Level 1
1572 * @tc.require: issueIAKC3I
1573 */
1574 HWTEST_F(ServiceTest, SUB_Service_UpdateTimer_0000, TestSize.Level1)
1575 {
1576 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_UpdateTimer_0000";
1577 try {
1578 string bundleName;
1579 bool result = 0;
1580 auto session_ = service->session_;
1581 service->session_ = nullptr;
1582 auto ret = service->UpdateTimer(bundleName, 0, result);
1583 service->session_ = session_;
1584 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1585
1586 service->isOccupyingSession_ = true;
1587 ret = service->UpdateTimer(bundleName, 0, result);
1588 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1589
1590 service->isOccupyingSession_ = false;
1591 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1592 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1593 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1594 EXPECT_CALL(*session, UpdateTimer(_, _, _)).WillOnce(Return(false));
1595 ret = service->UpdateTimer(bundleName, 0, result);
1596 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1597 } catch (...) {
1598 EXPECT_TRUE(false);
1599 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by UpdateTimer.";
1600 }
1601 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_UpdateTimer_0000";
1602 }
1603
1604 /**
1605 * @tc.number: SUB_Service_UpdateSendRate_0000
1606 * @tc.name: SUB_Service_UpdateSendRate_0000
1607 * @tc.desc: 测试 UpdateSendRate 的正常/异常分支
1608 * @tc.size: MEDIUM
1609 * @tc.type: FUNC
1610 * @tc.level Level 1
1611 * @tc.require: issueIAKC3I
1612 */
1613 HWTEST_F(ServiceTest, SUB_Service_UpdateSendRate_0000, TestSize.Level1)
1614 {
1615 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_UpdateSendRate_0000";
1616 try {
1617 string bundleName;
1618 bool result = 0;
1619 auto session_ = service->session_;
1620 service->session_ = nullptr;
1621 auto ret = service->UpdateSendRate(bundleName, 0, result);
1622 service->session_ = session_;
1623 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1624
1625 service->isOccupyingSession_ = true;
1626 ret = service->UpdateSendRate(bundleName, 0, result);
1627 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1628
1629 service->isOccupyingSession_ = false;
1630 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1631 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1632 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1633 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1634 ret = service->UpdateSendRate(bundleName, 0, result);
1635 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1636
1637 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1638 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1639 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1640 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1641 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1642 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1643 ret = service->UpdateSendRate(bundleName, 0, result);
1644 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1645 } catch (...) {
1646 EXPECT_TRUE(false);
1647 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by UpdateSendRate.";
1648 }
1649 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_UpdateSendRate_0000";
1650 }
1651
1652 /**
1653 * @tc.number: SUB_Service_UpdateSendRate_0100
1654 * @tc.name: SUB_Service_UpdateSendRate_0100
1655 * @tc.desc: 测试 UpdateSendRate 的正常/异常分支
1656 * @tc.size: MEDIUM
1657 * @tc.type: FUNC
1658 * @tc.level Level 1
1659 * @tc.require: issueIAKC3I
1660 */
1661 HWTEST_F(ServiceTest, SUB_Service_UpdateSendRate_0100, TestSize.Level1)
1662 {
1663 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_UpdateSendRate_0100";
1664 try {
1665 string bundleName;
1666 bool result = 0;
1667 service->isOccupyingSession_ = false;
1668 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1669 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1670 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1671 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1672 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1673 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1674 EXPECT_CALL(*svcProxy, UpdateFdSendRate(_, _)).WillOnce(Return(EPERM));
1675 auto ret = service->UpdateSendRate(bundleName, 0, result);
1676 EXPECT_EQ(ret, BError(BError::Codes::EXT_BROKEN_IPC).GetCode());
1677
1678 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
1679 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1680 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL));
1681 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1682 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1683 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1684 EXPECT_CALL(*svcProxy, UpdateFdSendRate(_, _)).WillOnce(Return(NO_ERROR));
1685 ret = service->UpdateSendRate(bundleName, 0, result);
1686 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1687 } catch (...) {
1688 EXPECT_TRUE(false);
1689 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by UpdateSendRate.";
1690 }
1691 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_UpdateSendRate_0100";
1692 }
1693
1694 /**
1695 * @tc.number: SUB_Service_BackupSA_0000
1696 * @tc.name: SUB_Service_BackupSA_0000
1697 * @tc.desc: 测试 BackupSA 的正常/异常分支
1698 * @tc.size: MEDIUM
1699 * @tc.type: FUNC
1700 * @tc.level Level 1
1701 * @tc.require: issueIAKC3I
1702 */
1703 HWTEST_F(ServiceTest, SUB_Service_BackupSA_0000, TestSize.Level1)
1704 {
1705 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_BackupSA_0000";
1706 try {
1707 string bundleName;
1708 shared_ptr<SABackupConnection> sa = nullptr;
1709 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1710 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1711 auto ret = service->BackupSA(bundleName);
1712 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1713
1714 sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr);
1715 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1716 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1717 ret = service->BackupSA(bundleName);
1718 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1719
1720 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1721 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1722 EXPECT_CALL(*saConnect, CallBackupSA()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1723 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1724 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0));
1725 ret = service->BackupSA(bundleName);
1726 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1727
1728 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP))
1729 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1730 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1731 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1732 EXPECT_CALL(*saConnect, CallBackupSA()).WillOnce(Return(BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode()));
1733 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1734 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0));
1735 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false));
1736 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
1737 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false));
1738 ret = service->BackupSA(bundleName);
1739 EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode());
1740
1741 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1742 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1743 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1744 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0));
1745 ret = service->BackupSA(bundleName);
1746 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1747 } catch (...) {
1748 EXPECT_TRUE(false);
1749 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by BackupSA.";
1750 }
1751 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_BackupSA_0000";
1752 }
1753
1754
1755 /**
1756 * @tc.number: SUB_Service_SADone_0000
1757 * @tc.name: SUB_Service_SADone_0000
1758 * @tc.desc: 测试 SADone 的正常/异常分支
1759 * @tc.size: MEDIUM
1760 * @tc.type: FUNC
1761 * @tc.level Level 1
1762 * @tc.require: issueIAKC3I
1763 */
1764 HWTEST_F(ServiceTest, SUB_Service_SADone_0000, TestSize.Level1)
1765 {
1766 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SADone_0000";
1767 try {
1768 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1769 auto ret = service->SADone(0, "");
1770 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1771
1772 shared_ptr<SABackupConnection> sa = nullptr;
1773 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1774 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1775 ret = service->SADone(0, "");
1776 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1777
1778 sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr);
1779 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1780 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1781 EXPECT_CALL(*saConnect, DisconnectBackupSAExt()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1782 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
1783 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
1784 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1785 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false));
1786 ret = service->SADone(0, "");
1787 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1788 } catch (...) {
1789 EXPECT_TRUE(false);
1790 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SADone.";
1791 }
1792 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SADone_0000";
1793 }
1794
1795 /**
1796 * @tc.number: SUB_Service_NotifyCallerCurAppDone_0000
1797 * @tc.name: SUB_Service_NotifyCallerCurAppDone_0000
1798 * @tc.desc: 测试 NotifyCallerCurAppDone 的正常/异常分支
1799 * @tc.size: MEDIUM
1800 * @tc.type: FUNC
1801 * @tc.level Level 1
1802 * @tc.require: issueIAKC3I
1803 */
1804 HWTEST_F(ServiceTest, SUB_Service_NotifyCallerCurAppDone_0000, TestSize.Level1)
1805 {
1806 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NotifyCallerCurAppDone_0000";
1807 try {
1808 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1809 service->NotifyCallerCurAppDone(0, "");
1810 EXPECT_TRUE(true);
1811
1812 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1813 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1814 EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0));
1815 service->NotifyCallerCurAppDone(0, "");
1816 EXPECT_TRUE(true);
1817
1818 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1819 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1820 EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return(0));
1821 service->NotifyCallerCurAppDone(0, "");
1822 EXPECT_TRUE(true);
1823 } catch (...) {
1824 EXPECT_TRUE(false);
1825 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by NotifyCallerCurAppDone.";
1826 }
1827 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_NotifyCallerCurAppDone_0000";
1828 }
1829
1830 /**
1831 * @tc.number: SUB_Service_ReportAppProcessInfo_0000
1832 * @tc.name: SUB_Service_ReportAppProcessInfo_0000
1833 * @tc.desc: 测试 ReportAppProcessInfo 的正常/异常分支
1834 * @tc.size: MEDIUM
1835 * @tc.type: FUNC
1836 * @tc.level Level 1
1837 * @tc.require: issueIAKC3I
1838 */
1839 HWTEST_F(ServiceTest, SUB_Service_ReportAppProcessInfo_0000, TestSize.Level1)
1840 {
1841 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ReportAppProcessInfo_0000";
1842 try {
1843 string processInfo;
1844 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1845 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(OHOS::Security::AccessToken::TOKEN_HAP));
1846 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1847 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1848 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1849 EXPECT_CALL(*srProxy, RestoreOnProcessInfo(_, _)).WillOnce(Return(0));
1850 auto ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_RESTORE);
1851 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1852
1853 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1854 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(OHOS::Security::AccessToken::TOKEN_HAP));
1855 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1856 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1857 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1858 EXPECT_CALL(*srProxy, IncrementalRestoreOnProcessInfo(_, _)).WillOnce(Return(0));
1859 ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_RESTORE);
1860 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1861
1862 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1863 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(OHOS::Security::AccessToken::TOKEN_HAP));
1864 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1865 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1866 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1867 EXPECT_CALL(*srProxy, BackupOnProcessInfo(_, _)).WillOnce(Return(0));
1868 ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_BACKUP);
1869 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1870
1871 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
1872 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(OHOS::Security::AccessToken::TOKEN_HAP));
1873 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
1874 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
1875 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1876 EXPECT_CALL(*srProxy, IncrementalBackupOnProcessInfo(_, _)).WillOnce(Return(0));
1877 ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_BACKUP);
1878 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1879 } catch (...) {
1880 EXPECT_TRUE(false);
1881 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ReportAppProcessInfo.";
1882 }
1883 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ReportAppProcessInfo_0000";
1884 }
1885
1886 /**
1887 * @tc.number: SUB_Service_TimeOutCallback_0000
1888 * @tc.name: SUB_Service_TimeOutCallback_0000
1889 * @tc.desc: 测试 TimeOutCallback 的正常/异常分支
1890 * @tc.size: MEDIUM
1891 * @tc.type: FUNC
1892 * @tc.level Level 1
1893 * @tc.require: issueIAKC3I
1894 */
1895 HWTEST_F(ServiceTest, SUB_Service_TimeOutCallback_0000, TestSize.Level1)
1896 {
1897 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TimeOutCallback_0000";
1898 try {
1899 string bundleName;
1900 auto fun = service->TimeOutCallback(nullptr, bundleName);
1901 fun();
1902 EXPECT_TRUE(true);
1903
1904 auto session_ = service->session_;
1905 service->session_ = nullptr;
1906 fun = service->TimeOutCallback(service, bundleName);
1907 fun();
1908 service->session_ = session_;
1909 EXPECT_TRUE(true);
1910 } catch (...) {
1911 EXPECT_TRUE(false);
1912 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TimeOutCallback.";
1913 }
1914 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TimeOutCallback_0000";
1915 }
1916
1917 /**
1918 * @tc.number: SUB_Service_DoTimeout_0000
1919 * @tc.name: SUB_Service_DoTimeout_0000
1920 * @tc.desc: 测试 DoTimeout 的正常/异常分支
1921 * @tc.size: MEDIUM
1922 * @tc.type: FUNC
1923 * @tc.level Level 1
1924 * @tc.require: issueIAKC3I
1925 */
1926 HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0000, TestSize.Level1)
1927 {
1928 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DoTimeout_0000";
1929 try {
1930 string bundleName;
1931 service->DoTimeout(nullptr, bundleName);
1932 EXPECT_TRUE(true);
1933
1934 auto session_ = service->session_;
1935 service->session_ = nullptr;
1936 service->DoTimeout(service, bundleName);
1937 service->session_ = session_;
1938 EXPECT_TRUE(true);
1939
1940 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1941 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1942 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1943 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1944 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true));
1945 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1946 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1947 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1948 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
1949 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
1950 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false));
1951 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false));
1952 service->DoTimeout(service, bundleName);
1953 EXPECT_TRUE(true);
1954
1955 shared_ptr<SABackupConnection> sa = nullptr;
1956 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
1957 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
1958 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1959 service->DoTimeout(service, bundleName);
1960 EXPECT_TRUE(true);
1961 } catch (...) {
1962 EXPECT_TRUE(false);
1963 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by DoTimeout.";
1964 }
1965 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_DoTimeout_0000";
1966 }
1967
1968 /**
1969 * @tc.number: SUB_Service_DoTimeout_0100
1970 * @tc.name: SUB_Service_DoTimeout_0100
1971 * @tc.desc: 测试 DoTimeout 的正常/异常分支
1972 * @tc.size: MEDIUM
1973 * @tc.type: FUNC
1974 * @tc.level Level 1
1975 * @tc.require: issueIAKC3I
1976 */
1977 HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0100, TestSize.Level1)
1978 {
1979 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DoTimeout_0100";
1980 try {
1981 string bundleName;
1982 shared_ptr<SABackupConnection> sa = nullptr;
1983 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
1984 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
1985 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1986 service->DoTimeout(service, bundleName);
1987 EXPECT_TRUE(true);
1988
1989 sa = nullptr;
1990 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
1991 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
1992 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1993 service->DoTimeout(service, bundleName);
1994 EXPECT_TRUE(true);
1995
1996 sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr);
1997 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1998 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
1999 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
2000 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)).WillOnce(Return(true));
2001 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
2002 EXPECT_CALL(*saConnect, DisconnectBackupSAExt()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2003 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
2004 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
2005 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false));
2006 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false));
2007 service->DoTimeout(service, bundleName);
2008 EXPECT_TRUE(true);
2009 } catch (...) {
2010 EXPECT_TRUE(false);
2011 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by DoTimeout.";
2012 }
2013 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_DoTimeout_0100";
2014 }
2015
2016 /**
2017 * @tc.number: SUB_Service_AddClearBundleRecord_0000
2018 * @tc.name: SUB_Service_AddClearBundleRecord_0000
2019 * @tc.desc: 测试 AddClearBundleRecord 的正常/异常分支
2020 * @tc.size: MEDIUM
2021 * @tc.type: FUNC
2022 * @tc.level Level 1
2023 * @tc.require: issueIAKC3I
2024 */
2025 HWTEST_F(ServiceTest, SUB_Service_AddClearBundleRecord_0000, TestSize.Level1)
2026 {
2027 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AddClearBundleRecord_0000";
2028 try {
2029 string bundleName;
2030 EXPECT_CALL(*cdConfig, InsertClearBundleRecord(_)).WillOnce(Return(false));
2031 service->AddClearBundleRecord(bundleName);
2032 EXPECT_TRUE(true);
2033
2034 EXPECT_CALL(*cdConfig, InsertClearBundleRecord(_)).WillOnce(Return(true));
2035 service->AddClearBundleRecord(bundleName);
2036 EXPECT_TRUE(true);
2037 } catch (...) {
2038 EXPECT_TRUE(false);
2039 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AddClearBundleRecord.";
2040 }
2041 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_AddClearBundleRecord_0000";
2042 }
2043
2044 /**
2045 * @tc.number: SUB_Service_DelClearBundleRecord_0000
2046 * @tc.name: SUB_Service_DelClearBundleRecord_0000
2047 * @tc.desc: 测试 DelClearBundleRecord 的正常/异常分支
2048 * @tc.size: MEDIUM
2049 * @tc.type: FUNC
2050 * @tc.level Level 1
2051 * @tc.require: issueIAKC3I
2052 */
2053 HWTEST_F(ServiceTest, SUB_Service_DelClearBundleRecord_0000, TestSize.Level1)
2054 {
2055 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DelClearBundleRecord_0000";
2056 try {
2057 vector<string> bundleNames { "bundleName" };
2058 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false));
2059 service->DelClearBundleRecord(bundleNames);
2060 EXPECT_TRUE(true);
2061
2062 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true));
2063 service->DelClearBundleRecord(bundleNames);
2064 EXPECT_TRUE(true);
2065 } catch (...) {
2066 EXPECT_TRUE(false);
2067 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by DelClearBundleRecord.";
2068 }
2069 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_DelClearBundleRecord_0000";
2070 }
2071
2072 /**
2073 * @tc.number: SUB_Service_ReleaseOnException_0000
2074 * @tc.name: SUB_Service_ReleaseOnException_0000
2075 * @tc.desc: 测试 ReleaseOnException 的正常/异常分支
2076 * @tc.size: MEDIUM
2077 * @tc.type: FUNC
2078 * @tc.level Level 1
2079 * @tc.require: issueIAKC3I
2080 */
2081 HWTEST_F(ServiceTest, SUB_Service_ReleaseOnException_0000, TestSize.Level1)
2082 {
2083 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ReleaseOnException_0000";
2084 try {
2085 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false));
2086 service->ReleaseOnException();
2087 EXPECT_TRUE(true);
2088
2089 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true));
2090 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
2091 service->isInRelease_ = false;
2092 service->ReleaseOnException();
2093 EXPECT_TRUE(true);
2094
2095 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true));
2096 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP));
2097 service->isInRelease_ = true;
2098 service->ReleaseOnException();
2099 EXPECT_TRUE(true);
2100
2101 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true));
2102 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
2103 service->isInRelease_ = true;
2104 auto session_ = service->session_;
2105 service->session_ = nullptr;
2106 service->ReleaseOnException();
2107 service->session_ = session_;
2108 EXPECT_TRUE(true);
2109 } catch (...) {
2110 EXPECT_TRUE(false);
2111 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ReleaseOnException.";
2112 }
2113 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ReleaseOnException_0000";
2114 }
2115
2116 /**
2117 * @tc.number: SUB_Service_ClearResidualBundleData_0000
2118 * @tc.name: SUB_Service_ClearResidualBundleData_0000
2119 * @tc.desc: 测试 ClearResidualBundleData 的正常/异常分支
2120 * @tc.size: MEDIUM
2121 * @tc.type: FUNC
2122 * @tc.level Level 1
2123 * @tc.require: issueIAKC3I
2124 */
2125 HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0000, TestSize.Level1)
2126 {
2127 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ClearResidualBundleData_0000";
2128 try {
2129 string bundleName;
2130 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2131 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2132 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2133 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2134 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2135 EXPECT_CALL(*session, GetScenario())
2136 .WillOnce(Return(IServiceReverseType::Scenario::CLEAN))
2137 .WillOnce(Return(IServiceReverseType::Scenario::CLEAN))
2138 .WillOnce(Return(IServiceReverseType::Scenario::CLEAN));
2139 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true));
2140 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true));
2141 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true));
2142 auto res = service->ClearResidualBundleData(bundleName);
2143 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2144
2145 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2146 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2147 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2148 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(false));
2149 EXPECT_CALL(*session, GetScenario())
2150 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
2151 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
2152 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
2153 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true));
2154 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true));
2155 res = service->ClearResidualBundleData(bundleName);
2156 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2157 } catch (...) {
2158 EXPECT_TRUE(false);
2159 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ClearResidualBundleData.";
2160 }
2161 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ClearResidualBundleData_0000";
2162 }
2163
2164 /**
2165 * @tc.number: SUB_Service_GetBackupInfoCmdHandle_0000
2166 * @tc.name: SUB_Service_GetBackupInfoCmdHandle_0000
2167 * @tc.desc: 测试 GetBackupInfoCmdHandle 的正常/异常分支
2168 * @tc.size: MEDIUM
2169 * @tc.type: FUNC
2170 * @tc.level Level 1
2171 * @tc.require: issueIAKC3I
2172 */
2173 HWTEST_F(ServiceTest, SUB_Service_GetBackupInfoCmdHandle_0000, TestSize.Level1)
2174 {
2175 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetBackupInfoCmdHandle_0000";
2176 try {
2177 BundleName bundleName;
2178 string result;
2179 EXPECT_CALL(*session, CreateBackupConnection(_)).WillOnce(Return(nullptr));
2180 auto res = service->GetBackupInfoCmdHandle(bundleName, result);
2181 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2182 } catch (...) {
2183 EXPECT_TRUE(false);
2184 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetBackupInfoCmdHandle.";
2185 }
2186 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetBackupInfoCmdHandle_0000";
2187 }
2188
2189 /**
2190 * @tc.number: SUB_Service_HandleCurBundleFileReady_0000
2191 * @tc.name: SUB_Service_HandleCurBundleFileReady_0000
2192 * @tc.desc: 测试 HandleCurBundleFileReady 的正常/异常分支
2193 * @tc.size: MEDIUM
2194 * @tc.type: FUNC
2195 * @tc.level Level 1
2196 * @tc.require: issueIAKC3I
2197 */
2198 HWTEST_F(ServiceTest, SUB_Service_HandleCurBundleFileReady_0000, TestSize.Level1)
2199 {
2200 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleCurBundleFileReady_0000";
2201 try {
2202 const string bundleName;
2203 const string fileName;
2204 bool isIncBackup = false;
2205 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
2206 auto res = service->HandleCurBundleFileReady(bundleName, fileName, isIncBackup);
2207 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2208
2209 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2210 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
2211 res = service->HandleCurBundleFileReady(bundleName, fileName, isIncBackup);
2212 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2213
2214 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2215 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2216 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2217 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
2218 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
2219 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2220 EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0));
2221 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2222 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED))
2223 .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
2224 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true));
2225 res = service->HandleCurBundleFileReady(bundleName, fileName, isIncBackup);
2226 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2227
2228 isIncBackup = true;
2229 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2230 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2231 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2232 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
2233 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
2234 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2235 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0));
2236 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2237 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
2238 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true));
2239 res = service->HandleCurBundleFileReady(bundleName, fileName, isIncBackup);
2240 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2241 } catch (...) {
2242 EXPECT_TRUE(false);
2243 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleCurBundleFileReady.";
2244 }
2245 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleCurBundleFileReady_0000";
2246 }
2247
2248 /**
2249 * @tc.number: SUB_Service_CallOnBundleEndByScenario_0100
2250 * @tc.name: SUB_Service_CallOnBundleEndByScenario_0100
2251 * @tc.desc: 测试 CallOnBundleEndByScenario 接口
2252 * @tc.size: MEDIUM
2253 * @tc.type: FUNC
2254 * @tc.level Level 1
2255 * @tc.require: I6F3GV
2256 */
2257 HWTEST_F(ServiceTest, SUB_Service_CallOnBundleEndByScenario_0100, testing::ext::TestSize.Level1)
2258 {
2259 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CallOnBundleEndByScenario_0100";
2260 try {
2261 auto session_ = service->session_;
2262 const std::string bundleName = "test";
2263 ErrCode errCode = BError(BError::Codes::OK);
2264
2265 service->session_ = nullptr;
2266 service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::FULL_RESTORE, errCode);
2267 EXPECT_TRUE(true);
2268
2269 service->session_ = session_;
2270 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2271 EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return(0));
2272 service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::FULL_RESTORE, errCode);
2273 EXPECT_TRUE(true);
2274
2275 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2276 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return(0));
2277 service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::INCREMENTAL_RESTORE, errCode);
2278 EXPECT_TRUE(true);
2279
2280 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2281 EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0));
2282 service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::FULL_BACKUP, errCode);
2283 EXPECT_TRUE(true);
2284
2285 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2286 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0));
2287 service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::INCREMENTAL_BACKUP, errCode);
2288 EXPECT_TRUE(true);
2289 } catch (...) {
2290 EXPECT_TRUE(false);
2291 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CallOnBundleEndByScenario.";
2292 }
2293 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CallOnBundleEndByScenario_0100";
2294 }
2295
2296 /**
2297 * @tc.number: SUB_Service_GetSupportBackupBundleNames_0100
2298 * @tc.name: SUB_Service_GetSupportBackupBundleNames_0100
2299 * @tc.desc: 测试 GetSupportBackupBundleNames 接口
2300 * @tc.size: MEDIUM
2301 * @tc.type: FUNC
2302 * @tc.level Level 1
2303 * @tc.require: I6F3GV
2304 */
2305 HWTEST_F(ServiceTest, SUB_Service_GetSupportBackupBundleNames_0100, testing::ext::TestSize.Level1)
2306 {
2307 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetSupportBackupBundleNames_0100";
2308 try {
2309 std::vector<BJsonEntityCaps::BundleInfo> backupInfos = {
2310 {.name = "test1", .appIndex = 0, .allToBackup = false, .versionName = ""},
2311 {.name = "test2", .appIndex = 0, .allToBackup = true, .versionName = ""}
2312 };
2313 bool isIncBackup = false;
2314 const std::vector<std::string> srcBundleNames;
2315 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")).WillOnce(Return(""));
2316 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2317 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0));
2318 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2319 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0));
2320 auto res = service->GetSupportBackupBundleNames(backupInfos, isIncBackup, srcBundleNames);
2321 EXPECT_EQ(res.size(), 1);
2322
2323 isIncBackup = true;
2324 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")).WillOnce(Return(""));
2325 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2326 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0));
2327 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
2328 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0));
2329 res = service->GetSupportBackupBundleNames(backupInfos, isIncBackup, srcBundleNames);
2330 EXPECT_EQ(res.size(), 1);
2331 } catch (...) {
2332 EXPECT_TRUE(false);
2333 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetSupportBackupBundleNames.";
2334 }
2335 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetSupportBackupBundleNames_0100";
2336 }
2337
2338 /**
2339 * @tc.number: SUB_Service_TryToConnectExt_0000
2340 * @tc.name: SUB_Service_TryToConnectExt_0000
2341 * @tc.desc: 测试 TryToConnectExt 的正常/异常分支
2342 * @tc.size: MEDIUM
2343 * @tc.type: FUNC
2344 * @tc.level Level 1
2345 * @tc.require: IC7RHQ
2346 */
2347 HWTEST_F(ServiceTest, SUB_Service_TryToConnectExt_0000, testing::ext::TestSize.Level1)
2348 {
2349 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TryToConnectExt_0000";
2350 try {
2351 std::string bundleName = "123";
__anon8b46c78a0102(const string &&bundleName, bool isCleanCalled) 2352 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anon8b46c78a0202(const string &&bundleName) 2353 auto callConnected = [](const string &&bundleName) {};
2354 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
2355 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
2356 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2357 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2358 EXPECT_CALL(*session, CreateBackupConnection(_)).WillOnce(Return(connectPtr));
2359 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2360 EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::UNDEFINED));
2361 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2362 auto res = service->TryToConnectExt(bundleName, connectPtr);
2363 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2364 } catch (...) {
2365 EXPECT_TRUE(false);
2366 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TryToConnectExt.";
2367 }
2368 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TryToConnectExt_0000";
2369 }
2370
2371 /**
2372 * @tc.number: SUB_Service_TryToConnectExt_0100
2373 * @tc.name: SUB_Service_TryToConnectExt_0100
2374 * @tc.desc: 测试 TryToConnectExt 的正常/异常分支
2375 * @tc.size: MEDIUM
2376 * @tc.type: FUNC
2377 * @tc.level Level 1
2378 * @tc.require: IC7RHQ
2379 */
2380 HWTEST_F(ServiceTest, SUB_Service_TryToConnectExt_0100, testing::ext::TestSize.Level1)
2381 {
2382 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TryToConnectExt_0100";
2383 try {
2384 std::string bundleName = "123";
__anon8b46c78a0302(const string &&bundleName, bool isCleanCalled) 2385 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anon8b46c78a0402(const string &&bundleName) 2386 auto callConnected = [](const string &&bundleName) {};
2387 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
2388 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
2389 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2390 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2391 EXPECT_CALL(*session, CreateBackupConnection(_)).WillRepeatedly(Return(nullptr));
2392 auto res = service->TryToConnectExt(bundleName, connectPtr);
2393 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2394 } catch (...) {
2395 EXPECT_TRUE(false);
2396 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TryToConnectExt.";
2397 }
2398 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TryToConnectExt_0100";
2399 }
2400
2401 /**
2402 * @tc.number: SUB_Service_TryToConnectExt_0200
2403 * @tc.name: SUB_Service_TryToConnectExt_0200
2404 * @tc.desc: 测试 TryToConnectExt 的正常/异常分支
2405 * @tc.size: MEDIUM
2406 * @tc.type: FUNC
2407 * @tc.level Level 1
2408 * @tc.require: IC7RHQ
2409 */
2410 HWTEST_F(ServiceTest, SUB_Service_TryToConnectExt_0200, testing::ext::TestSize.Level1)
2411 {
2412 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TryToConnectExt_0200";
2413 try {
2414 std::string bundleName = "123";
__anon8b46c78a0502(const string &&bundleName, bool isCleanCalled) 2415 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anon8b46c78a0602(const string &&bundleName) 2416 auto callConnected = [](const string &&bundleName) {};
2417 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
2418 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
2419 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2420 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2421 EXPECT_CALL(*session, CreateBackupConnection(_)).WillOnce(Return(connectPtr));
2422 EXPECT_CALL(*session, GetSessionUserId()).WillRepeatedly(Return(0));
2423 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
2424 .WillRepeatedly(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
2425 EXPECT_CALL(*skeleton, GetCallingUid()).WillRepeatedly(Return(BConstants::XTS_UID));
2426 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2427 EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::UNDEFINED));
2428 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2429 auto res = service->TryToConnectExt(bundleName, connectPtr);
2430 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2431 } catch (...) {
2432 EXPECT_TRUE(false);
2433 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TryToConnectExt.";
2434 }
2435 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TryToConnectExt_0200";
2436 }
2437
2438 /**
2439 * @tc.number: SUB_Service_TryToConnectExt_0300
2440 * @tc.name: SUB_Service_TryToConnectExt_0300
2441 * @tc.desc: 测试 TryToConnectExt 的正常/异常分支
2442 * @tc.size: MEDIUM
2443 * @tc.type: FUNC
2444 * @tc.level Level 1
2445 * @tc.require: IC7RHQ
2446 */
2447 HWTEST_F(ServiceTest, SUB_Service_TryToConnectExt_0300, testing::ext::TestSize.Level1)
2448 {
2449 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TryToConnectExt_0300";
2450 try {
2451 std::string bundleName = "123";
__anon8b46c78a0702(const string &&bundleName, bool isCleanCalled) 2452 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anon8b46c78a0802(const string &&bundleName) 2453 auto callConnected = [](const string &&bundleName) {};
2454 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
2455 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
2456 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2457 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2458 EXPECT_CALL(*session, GetSessionUserId()).WillRepeatedly(Return(0));
2459 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
2460 .WillRepeatedly(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
2461 EXPECT_CALL(*skeleton, GetCallingUid()).WillRepeatedly(Return(BConstants::XTS_UID));
2462 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2463 EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::UNDEFINED));
2464 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _))
2465 .WillOnce(Return(BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode()));
2466 auto res = service->TryToConnectExt(bundleName, connectPtr);
2467 EXPECT_EQ(res, BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode());
2468 } catch (...) {
2469 EXPECT_TRUE(false);
2470 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TryToConnectExt.";
2471 }
2472 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TryToConnectExt_0300";
2473 }
2474
2475 /**
2476 * @tc.number: SUB_Service_CleanBundleTempDir_0000
2477 * @tc.name: SUB_Service_CleanBundleTempDir_0000
2478 * @tc.desc: 测试 CleanBundleTempDir 的正常/异常分支
2479 * @tc.size: MEDIUM
2480 * @tc.type: FUNC
2481 * @tc.level Level 1
2482 * @tc.require: IC7RHQ
2483 */
2484 HWTEST_F(ServiceTest, SUB_Service_CleanBundleTempDir_0000, testing::ext::TestSize.Level1)
2485 {
2486 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CleanBundleTempDir_0000";
2487 try {
2488 std::string bundleName = "123";
2489 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
2490 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
2491 EXPECT_CALL(*token, VerifyAccessToken(_, _))
2492 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
2493 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
2494 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
2495 auto res = service->CleanBundleTempDir(bundleName);
2496 EXPECT_EQ(res, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
2497 } catch (...) {
2498 EXPECT_TRUE(false);
2499 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CleanBundleTempDir.";
2500 }
2501 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CleanBundleTempDir_0000";
2502 }
2503
2504 /**
2505 * @tc.number: SUB_Service_CleanBundleTempDir_0100
2506 * @tc.name: SUB_Service_CleanBundleTempDir_0100
2507 * @tc.desc: 测试 CleanBundleTempDir 的正常/异常分支
2508 * @tc.size: MEDIUM
2509 * @tc.type: FUNC
2510 * @tc.level Level 1
2511 * @tc.require: IC7RHQ
2512 */
2513 HWTEST_F(ServiceTest, SUB_Service_CleanBundleTempDir_0100, testing::ext::TestSize.Level1)
2514 {
2515 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CleanBundleTempDir_0100";
2516 try {
2517 std::string bundleName = "123";
2518 auto session_ = service->session_;
2519 service->session_ = nullptr;
2520 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
2521 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
2522 EXPECT_CALL(*token, VerifyAccessToken(_, _))
2523 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
2524 auto res = service->CleanBundleTempDir(bundleName);
2525 service->session_ = session_;
2526 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2527 } catch (...) {
2528 EXPECT_TRUE(false);
2529 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CleanBundleTempDir.";
2530 }
2531 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CleanBundleTempDir_0100";
2532 }
2533
2534 /**
2535 * @tc.number: SUB_Service_CleanBundleTempDir_0200
2536 * @tc.name: SUB_Service_CleanBundleTempDir_0200
2537 * @tc.desc: 测试 CleanBundleTempDir 的正常/异常分支
2538 * @tc.size: MEDIUM
2539 * @tc.type: FUNC
2540 * @tc.level Level 1
2541 * @tc.require: IC7RHQ
2542 */
2543 HWTEST_F(ServiceTest, SUB_Service_CleanBundleTempDir_0200, testing::ext::TestSize.Level1)
2544 {
2545 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CleanBundleTempDir_0200";
2546 try {
2547 std::string bundleName = "123";
__anon8b46c78a0902(const string &&bundleName, bool isCleanCalled) 2548 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anon8b46c78a0a02(const string &&bundleName) 2549 auto callConnected = [](const string &&bundleName) {};
2550 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
2551 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
2552 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
2553 EXPECT_CALL(*token, VerifyAccessToken(_, _))
2554 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
2555 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
2556 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2557 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2558 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2559 EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::UNDEFINED));
2560 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2561 auto res = service->CleanBundleTempDir(bundleName);
2562 EXPECT_EQ(res, BError(BError::Codes::OK).GetCode());
2563 } catch (...) {
2564 EXPECT_TRUE(false);
2565 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CleanBundleTempDir.";
2566 }
2567 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CleanBundleTempDir_0200";
2568 }
2569
2570 /**
2571 * @tc.number: SUB_Service_CleanBundleTempDir_0300
2572 * @tc.name: SUB_Service_CleanBundleTempDir_0300
2573 * @tc.desc: 测试 CleanBundleTempDir 的正常/异常分支
2574 * @tc.size: MEDIUM
2575 * @tc.type: FUNC
2576 * @tc.level Level 1
2577 * @tc.require: IC7RHQ
2578 */
2579 HWTEST_F(ServiceTest, SUB_Service_CleanBundleTempDir_0300, testing::ext::TestSize.Level1)
2580 {
2581 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CleanBundleTempDir_0300";
2582 try {
2583 std::string bundleName = "123";
__anon8b46c78a0b02(const string &&bundleName, bool isCleanCalled) 2584 auto callDied = [](const string &&bundleName, bool isCleanCalled) {};
__anon8b46c78a0c02(const string &&bundleName) 2585 auto callConnected = [](const string &&bundleName) {};
2586 auto connectPtr = sptr(new SvcBackupConnection(callDied, callConnected, bundleName));
2587 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
2588 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
2589 EXPECT_CALL(*token, VerifyAccessToken(_, _))
2590 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
2591 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(wptr(connectPtr)));
2592 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
2593 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true));
2594 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2595 EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::UNDEFINED));
2596 EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2597 auto res = service->CleanBundleTempDir(bundleName);
2598 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2599 } catch (...) {
2600 EXPECT_TRUE(false);
2601 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CleanBundleTempDir.";
2602 }
2603 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CleanBundleTempDir_0300";
2604 }
2605
2606 /**
2607 * @tc.number: SUB_Service_HandleExtDisconnect_0000
2608 * @tc.name: SUB_Service_HandleExtDisconnect_0000
2609 * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支
2610 * @tc.size: MEDIUM
2611 * @tc.type: FUNC
2612 * @tc.level Level 1
2613 * @tc.require: IC7RHQ
2614 */
2615 HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0000, testing::ext::TestSize.Level1)
2616 {
2617 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0000";
2618 try {
2619 BackupRestoreScenario scenario = BackupRestoreScenario::FULL_RESTORE;
2620 bool isAppResultReport = false;
2621 ErrCode appErrCode = BError(BError::Codes::OK).GetCode();
2622 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillRepeatedly(Return(0));
2623 EXPECT_CALL(*token, GetTokenType(_)).WillRepeatedly(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
2624 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillRepeatedly(Return(1));
2625 EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
2626 .WillRepeatedly(Return(make_pair<bool, int32_t>(false, -1)));
2627 EXPECT_CALL(*skeleton, GetCallingUid()).WillRepeatedly(Return(BConstants::SYSTEM_UID));
2628 auto ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2629 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2630
2631 isAppResultReport = true;
2632 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
2633 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false));
2634 ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2635 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2636 } catch (...) {
2637 EXPECT_TRUE(false);
2638 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect.";
2639 }
2640 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0000";
2641 }
2642
2643 /**
2644 * @tc.number: SUB_Service_HandleExtDisconnect_0100
2645 * @tc.name: SUB_Service_HandleExtDisconnect_0100
2646 * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支
2647 * @tc.size: MEDIUM
2648 * @tc.type: FUNC
2649 * @tc.level Level 1
2650 * @tc.require: IC7RHQ
2651 */
2652 HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0100, testing::ext::TestSize.Level1)
2653 {
2654 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0100";
2655 try {
2656 BackupRestoreScenario scenario = BackupRestoreScenario::FULL_RESTORE;
2657 bool isAppResultReport = false;
2658 ErrCode appErrCode = BError(BError::Codes::OK).GetCode();
2659 std::string bundleName = "test";
2660 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillRepeatedly(Return(0));
2661 EXPECT_CALL(*token, GetTokenType(_)).WillRepeatedly(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
2662 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillRepeatedly(Return(0));
2663 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillRepeatedly(Return("test"));
2664 EXPECT_CALL(*session, GetExtConnection(_)).WillRepeatedly(Return(nullptr));
2665 auto ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2666 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2667
2668 service->backupExtMutexMap_[bundleName] = nullptr;
2669 ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2670 service->backupExtMutexMap_.clear();
2671 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2672 } catch (...) {
2673 EXPECT_TRUE(false);
2674 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect.";
2675 }
2676 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0100";
2677 }
2678
2679 /**
2680 * @tc.number: SUB_Service_HandleExtDisconnect_0200
2681 * @tc.name: SUB_Service_HandleExtDisconnect_0200
2682 * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支
2683 * @tc.size: MEDIUM
2684 * @tc.type: FUNC
2685 * @tc.level Level 1
2686 * @tc.require: IC7RHQ
2687 */
2688 HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0200, testing::ext::TestSize.Level1)
2689 {
2690 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0200";
2691 try {
2692 BackupRestoreScenario scenario = BackupRestoreScenario::FULL_BACKUP;
2693 bool isAppResultReport = false;
2694 ErrCode appErrCode = BError(BError::Codes::OK).GetCode();
2695 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
2696 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
2697 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
2698 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return(""));
2699 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2700 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
2701 auto ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2702 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
2703 } catch (...) {
2704 EXPECT_TRUE(false);
2705 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect.";
2706 }
2707 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0200";
2708 }
2709
2710 /**
2711 * @tc.number: SUB_Service_HandleExtDisconnect_0300
2712 * @tc.name: SUB_Service_HandleExtDisconnect_0300
2713 * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支
2714 * @tc.size: MEDIUM
2715 * @tc.type: FUNC
2716 * @tc.level Level 1
2717 * @tc.require: IC7RHQ
2718 */
2719 HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0300, testing::ext::TestSize.Level1)
2720 {
2721 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0300";
2722 try {
2723 BackupRestoreScenario scenario = BackupRestoreScenario::FULL_RESTORE;
2724 bool isAppResultReport = true;
2725 ErrCode appErrCode = BError(BError::Codes::OK).GetCode();
2726 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillRepeatedly(Return(0));
2727 EXPECT_CALL(*token, GetTokenType(_)).WillRepeatedly(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
2728 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillRepeatedly(Return(0));
2729 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillRepeatedly(Return(""));
2730 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillRepeatedly(Return(false));
2731 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillRepeatedly(Return(false));
2732 auto ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2733 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
2734
2735 scenario = BackupRestoreScenario::FULL_RESTORE;
2736 ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2737 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
2738
2739 isAppResultReport = false;
2740 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
2741 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
2742 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2743 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
2744 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
2745 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
2746 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
2747 EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::UNDEFINED));
2748 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false));
2749 ret = service->HandleExtDisconnect(scenario, isAppResultReport, appErrCode);
2750 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
2751 } catch (...) {
2752 EXPECT_TRUE(false);
2753 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect.";
2754 }
2755 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0300";
2756 }
2757 }