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
18 #include "backup_para_mock.h"
19 #include "bms_adapter_mock.h"
20 #include "b_json/b_json_entity_caps.h"
21 #include "b_jsonutil_mock.h"
22 #include "ipc_skeleton_mock.h"
23 #include "sa_backup_connection_mock.h"
24 #include "service_reverse_proxy_mock.h"
25 #include "svc_backup_connection_mock.h"
26 #include "svc_extension_proxy_mock.h"
27 #include "svc_session_manager_mock.h"
28
29 #include "service_incremental.cpp"
30
31 namespace OHOS::FileManagement::Backup {
32 using namespace std;
33
34 class BService {
35 public:
36 virtual UniqueFd GetLocalCapabilities() = 0;
37 virtual ErrCode VerifyCallerAndGetCallerName(std::string&) = 0;
38 virtual ErrCode InitRestoreSession(sptr<IServiceReverse>) = 0;
39 virtual ErrCode InitRestoreSession(sptr<IServiceReverse>, std::string&) = 0;
40 virtual ErrCode InitBackupSession(sptr<IServiceReverse>) = 0;
41 virtual ErrCode InitBackupSession(sptr<IServiceReverse>, std::string&) = 0;
42 virtual ErrCode Start() = 0;
43 virtual ErrCode PublishFile(const BFileInfo&) = 0;
44 virtual ErrCode AppFileReady(const string&, UniqueFd, int32_t) = 0;
45 virtual ErrCode AppDone(ErrCode) = 0;
46 virtual ErrCode ServiceResultReport(const std::string, BackupRestoreScenario, ErrCode) = 0;
47 virtual ErrCode AppendBundlesRestoreSession(UniqueFd, const std::vector<BundleName>&,
48 const std::vector<std::string>&, RestoreTypeEnum, int32_t) = 0;
49 virtual ErrCode AppendBundlesRestoreSession(UniqueFd, const std::vector<BundleName>&, RestoreTypeEnum,
50 int32_t) = 0;
51 virtual ErrCode AppendBundlesBackupSession(const std::vector<BundleName>&) = 0;
52 virtual ErrCode AppendBundlesDetailsBackupSession(const std::vector<BundleName>&,
53 const std::vector<std::string>&) = 0;
54 virtual ErrCode Finish() = 0;
55 virtual ErrCode LaunchBackupExtension(const BundleName&) = 0;
56 virtual ErrCode LaunchBackupSAExtension(const BundleName&) = 0;
57 virtual ErrCode GetFileHandle(const string&, const string&) = 0;
58 virtual int Dump(int, const vector<u16string>&) = 0;
59 virtual ErrCode VerifyCaller() = 0;
60 virtual ErrCode VerifyCaller(IServiceReverse::Scenario) = 0;
61 virtual int32_t GetUserIdDefault() = 0;
62 virtual ErrCode GetBackupInfo(BundleName&, std::string&) = 0;
63 virtual ErrCode UpdateTimer(BundleName&, uint32_t, bool&) = 0;
64 virtual ErrCode UpdateSendRate(std::string&, int32_t, bool&) = 0;
65 virtual ErrCode ReportAppProcessInfo(const std::string, BackupRestoreScenario) = 0;
66 virtual ErrCode StartExtTimer(bool&) = 0;
67 virtual ErrCode StartFwkTimer(bool&) = 0;
68 virtual ErrCode StopExtTimer(bool&) = 0;
69 virtual ErrCode RefreshDataSize(int64_t) = 0;
70 virtual std::string GetCallerName() = 0;
71 virtual bool IsReportBundleExecFail(const std::string&) = 0;
72 virtual bool IsReportFileReadyFail(const std::string&) = 0;
73 virtual std::vector<std::string> GetSupportBackupBundleNames(vector<BJsonEntityCaps::BundleInfo>&, bool,
74 const vector<string>&) = 0;
75 virtual ErrCode HandleCurBundleFileReady(const std::string&, const std::string&, bool) = 0;
76 virtual ErrCode HandleCurAppDone(ErrCode, const std::string&, bool) = 0;
77 virtual UniqueFd GetLocalCapabilitiesForBundleInfos() = 0;
78 virtual ErrCode GetBackupDataSize(bool, vector<BIncrementalData>) = 0;
79 public:
80 virtual bool UpdateToRestoreBundleMap(const string&, const string&) = 0;
81 public:
82 BService() = default;
83 virtual ~BService() = default;
84 public:
85 static inline std::shared_ptr<BService> serviceMock = nullptr;
86 };
87
88 class ServiceMock : public BService {
89 public:
90 MOCK_METHOD(UniqueFd, GetLocalCapabilities, ());
91 MOCK_METHOD(ErrCode, VerifyCallerAndGetCallerName, (std::string&));
92 MOCK_METHOD(ErrCode, InitRestoreSession, (sptr<IServiceReverse>));
93 MOCK_METHOD(ErrCode, InitRestoreSession, (sptr<IServiceReverse>, std::string&));
94 MOCK_METHOD(ErrCode, InitBackupSession, (sptr<IServiceReverse>));
95 MOCK_METHOD(ErrCode, InitBackupSession, ((sptr<IServiceReverse>), std::string&));
96 MOCK_METHOD(ErrCode, Start, ());
97 MOCK_METHOD(ErrCode, PublishFile, (const BFileInfo&));
98 MOCK_METHOD(ErrCode, AppFileReady, (const string&, UniqueFd, int32_t));
99 MOCK_METHOD(ErrCode, AppDone, (ErrCode));
100 MOCK_METHOD(ErrCode, ServiceResultReport, (const std::string, BackupRestoreScenario, ErrCode));
101 MOCK_METHOD(ErrCode, AppendBundlesRestoreSession, (UniqueFd, (const std::vector<BundleName>&),
102 (const std::vector<std::string>&), RestoreTypeEnum, int32_t));
103 MOCK_METHOD(ErrCode, AppendBundlesRestoreSession, (UniqueFd, (const std::vector<BundleName>&), RestoreTypeEnum,
104 int32_t));
105 MOCK_METHOD(ErrCode, AppendBundlesBackupSession, (const std::vector<BundleName>&));
106 MOCK_METHOD(ErrCode, AppendBundlesDetailsBackupSession, ((const std::vector<BundleName>&),
107 (const std::vector<std::string>&)));
108 MOCK_METHOD(ErrCode, Finish, ());
109 MOCK_METHOD(ErrCode, LaunchBackupExtension, (const BundleName&));
110 MOCK_METHOD(ErrCode, LaunchBackupSAExtension, (const BundleName&));
111 MOCK_METHOD(ErrCode, GetFileHandle, (const string&, const string&));
112 MOCK_METHOD(int, Dump, (int, const vector<u16string>&));
113 MOCK_METHOD(ErrCode, VerifyCaller, ());
114 MOCK_METHOD(ErrCode, VerifyCaller, (IServiceReverse::Scenario));
115 MOCK_METHOD(int32_t, GetUserIdDefault, ());
116 MOCK_METHOD(ErrCode, GetBackupInfo, (BundleName&, std::string&));
117 MOCK_METHOD(ErrCode, UpdateTimer, (BundleName&, uint32_t, bool&));
118 MOCK_METHOD(ErrCode, UpdateSendRate, (std::string&, int32_t, bool&));
119 MOCK_METHOD(ErrCode, ReportAppProcessInfo, (const std::string, BackupRestoreScenario));
120 MOCK_METHOD(ErrCode, StartExtTimer, (bool&));
121 MOCK_METHOD(ErrCode, StartFwkTimer, (bool&));
122 MOCK_METHOD(ErrCode, StopExtTimer, (bool&));
123 MOCK_METHOD(ErrCode, RefreshDataSize, (int64_t));
124 MOCK_METHOD(std::string, GetCallerName, ());
125 MOCK_METHOD(bool, IsReportBundleExecFail, (const std::string&));
126 MOCK_METHOD(bool, IsReportFileReadyFail, (const std::string&));
127 MOCK_METHOD(std::vector<std::string>, GetSupportBackupBundleNames, ((vector<BJsonEntityCaps::BundleInfo>&), bool,
128 (const vector<string>&)));
129 MOCK_METHOD(ErrCode, HandleCurBundleFileReady, (const std::string&, const std::string&, bool));
130 MOCK_METHOD(ErrCode, HandleCurAppDone, (ErrCode, const std::string&, bool));
131 MOCK_METHOD(UniqueFd, GetLocalCapabilitiesForBundleInfos, ());
132 MOCK_METHOD(ErrCode, GetBackupDataSize, (bool, vector<BIncrementalData>));
133 public:
134 MOCK_METHOD(bool, UpdateToRestoreBundleMap, (const string&, const string&));
135 };
136
OnStart()137 void Service::OnStart() {}
138
OnStop()139 void Service::OnStop() {}
140
GetLocalCapabilities()141 UniqueFd Service::GetLocalCapabilities()
142 {
143 return BService::serviceMock->GetLocalCapabilities();
144 }
145
StopAll(const wptr<IRemoteObject> &,bool)146 void Service::StopAll(const wptr<IRemoteObject>&, bool) {}
147
VerifyCallerAndGetCallerName(std::string & bundleName)148 ErrCode Service::VerifyCallerAndGetCallerName(std::string &bundleName)
149 {
150 return BService::serviceMock->VerifyCallerAndGetCallerName(bundleName);
151 }
152
InitRestoreSession(sptr<IServiceReverse> remote)153 ErrCode Service::InitRestoreSession(sptr<IServiceReverse> remote)
154 {
155 return BService::serviceMock->InitRestoreSession(remote);
156 }
157
InitRestoreSession(sptr<IServiceReverse> remote,std::string & errMsg)158 ErrCode Service::InitRestoreSession(sptr<IServiceReverse> remote, std::string &errMsg)
159 {
160 return BService::serviceMock->InitRestoreSession(remote, errMsg);
161 }
162
InitBackupSession(sptr<IServiceReverse> remote)163 ErrCode Service::InitBackupSession(sptr<IServiceReverse> remote)
164 {
165 return BService::serviceMock->InitBackupSession(remote);
166 }
167
InitBackupSession(sptr<IServiceReverse> remote,std::string & errMsg)168 ErrCode Service::InitBackupSession(sptr<IServiceReverse> remote, std::string &errMsg)
169 {
170 return BService::serviceMock->InitBackupSession(remote, errMsg);
171 }
172
Start()173 ErrCode Service::Start()
174 {
175 return BService::serviceMock->Start();
176 }
177
PublishFile(const BFileInfo & fileInfo)178 ErrCode Service::PublishFile(const BFileInfo &fileInfo)
179 {
180 return BService::serviceMock->PublishFile(fileInfo);
181 }
182
AppFileReady(const string & fileName,UniqueFd fd,int32_t errCode)183 ErrCode Service::AppFileReady(const string &fileName, UniqueFd fd, int32_t errCode)
184 {
185 return BService::serviceMock->AppFileReady(fileName, move(fd), errCode);
186 }
187
AppDone(ErrCode errCode)188 ErrCode Service::AppDone(ErrCode errCode)
189 {
190 return BService::serviceMock->AppDone(errCode);
191 }
192
ServiceResultReport(const std::string restoreRetInfo,BackupRestoreScenario sennario,ErrCode errCode)193 ErrCode Service::ServiceResultReport(const std::string restoreRetInfo, BackupRestoreScenario sennario, ErrCode errCode)
194 {
195 return BService::serviceMock->ServiceResultReport(restoreRetInfo, sennario, errCode);
196 }
197
AppendBundlesRestoreSession(UniqueFd fd,const std::vector<BundleName> & bundleNames,const std::vector<std::string> & detailInfos,RestoreTypeEnum restoreType,int32_t userId)198 ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, const std::vector<BundleName> &bundleNames,
199 const std::vector<std::string> &detailInfos, RestoreTypeEnum restoreType, int32_t userId)
200 {
201 return BService::serviceMock->AppendBundlesRestoreSession(move(fd), bundleNames, detailInfos, restoreType, userId);
202 }
203
AppendBundlesRestoreSession(UniqueFd fd,const std::vector<BundleName> & bundleNames,RestoreTypeEnum restoreType,int32_t userId)204 ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, const std::vector<BundleName> &bundleNames,
205 RestoreTypeEnum restoreType, int32_t userId)
206 {
207 return BService::serviceMock->AppendBundlesRestoreSession(move(fd), bundleNames, restoreType, userId);
208 }
209
AppendBundlesBackupSession(const std::vector<BundleName> & bundleNames)210 ErrCode Service::AppendBundlesBackupSession(const std::vector<BundleName> &bundleNames)
211 {
212 return BService::serviceMock->AppendBundlesBackupSession(bundleNames);
213 }
214
AppendBundlesDetailsBackupSession(const std::vector<BundleName> & bundleNames,const std::vector<std::string> & bundleInfos)215 ErrCode Service::AppendBundlesDetailsBackupSession(const std::vector<BundleName> &bundleNames,
216 const std::vector<std::string> &bundleInfos)
217 {
218 return BService::serviceMock->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos);
219 }
220
Finish()221 ErrCode Service::Finish()
222 {
223 return BService::serviceMock->Finish();
224 }
225
LaunchBackupExtension(const BundleName & bundleName)226 ErrCode Service::LaunchBackupExtension(const BundleName &bundleName)
227 {
228 return BService::serviceMock->LaunchBackupExtension(bundleName);
229 }
230
LaunchBackupSAExtension(const BundleName & bundleName)231 ErrCode Service::LaunchBackupSAExtension(const BundleName &bundleName)
232 {
233 return BService::serviceMock->LaunchBackupSAExtension(bundleName);
234 }
235
GetFileHandle(const string & bundleName,const string & fileName)236 ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName)
237 {
238 return BService::serviceMock->GetFileHandle(bundleName, fileName);
239 }
240
OnBackupExtensionDied(const string &&,bool)241 void Service::OnBackupExtensionDied(const string&&, bool) {}
242
ExtConnectDied(const string &)243 void Service::ExtConnectDied(const string&) {}
244
ExtStart(const string &)245 void Service::ExtStart(const string&) {}
246
Dump(int fd,const vector<u16string> & args)247 int Service::Dump(int fd, const vector<u16string> &args)
248 {
249 return BService::serviceMock->Dump(fd, args);
250 }
251
ExtConnectFailed(const string &,ErrCode)252 void Service::ExtConnectFailed(const string&, ErrCode) {}
253
ExtConnectDone(string)254 void Service::ExtConnectDone(string) {}
255
ClearSessionAndSchedInfo(const string &)256 void Service::ClearSessionAndSchedInfo(const string&) {}
257
VerifyCaller()258 ErrCode Service::VerifyCaller()
259 {
260 return BService::serviceMock->VerifyCaller();
261 }
262
VerifyCaller(IServiceReverse::Scenario scenario)263 ErrCode Service::VerifyCaller(IServiceReverse::Scenario scenario)
264 {
265 return BService::serviceMock->VerifyCaller(scenario);
266 }
267
GetUserIdDefault()268 int32_t Service::GetUserIdDefault()
269 {
270 return BService::serviceMock->GetUserIdDefault();
271 }
272
OnAllBundlesFinished(ErrCode)273 void Service::OnAllBundlesFinished(ErrCode) {}
274
OnStartSched()275 void Service::OnStartSched() {}
276
SendStartAppGalleryNotify(const BundleName &)277 void Service::SendStartAppGalleryNotify(const BundleName&) {}
278
SessionDeactive()279 void Service::SessionDeactive() {}
280
GetBackupInfo(BundleName & bundleName,std::string & result)281 ErrCode Service::GetBackupInfo(BundleName &bundleName, std::string &result)
282 {
283 return BService::serviceMock->GetBackupInfo(bundleName, result);
284 }
285
UpdateTimer(BundleName & bundleName,uint32_t timeOut,bool & result)286 ErrCode Service::UpdateTimer(BundleName &bundleName, uint32_t timeOut, bool &result)
287 {
288 return BService::serviceMock->UpdateTimer(bundleName, timeOut, result);
289 }
290
UpdateSendRate(std::string & bundleName,int32_t sendRate,bool & result)291 ErrCode Service::UpdateSendRate(std::string &bundleName, int32_t sendRate, bool &result)
292 {
293 return BService::serviceMock->UpdateSendRate(bundleName, sendRate, result);
294 }
295
OnSABackup(const std::string &,const int &,const std::string &,const ErrCode &)296 void Service::OnSABackup(const std::string&, const int&, const std::string&, const ErrCode&) {}
297
OnSARestore(const std::string &,const std::string &,const ErrCode &)298 void Service::OnSARestore(const std::string&, const std::string&, const ErrCode&) {}
299
NotifyCallerCurAppDone(ErrCode,const std::string &)300 void Service::NotifyCallerCurAppDone(ErrCode, const std::string&) {}
301
SendEndAppGalleryNotify(const BundleName &)302 void Service::SendEndAppGalleryNotify(const BundleName&) {}
303
NoticeClientFinish(const string &,ErrCode)304 void Service::NoticeClientFinish(const string&, ErrCode) {}
305
ReportAppProcessInfo(const std::string processInfo,BackupRestoreScenario sennario)306 ErrCode Service::ReportAppProcessInfo(const std::string processInfo, BackupRestoreScenario sennario)
307 {
308 return BService::serviceMock->ReportAppProcessInfo(processInfo, sennario);
309 }
310
StartExtTimer(bool & isExtStart)311 ErrCode Service::StartExtTimer(bool &isExtStart)
312 {
313 return BService::serviceMock->StartExtTimer(isExtStart);
314 }
315
StartFwkTimer(bool & isFwkStart)316 ErrCode Service::StartFwkTimer(bool &isFwkStart)
317 {
318 return BService::serviceMock->StartFwkTimer(isFwkStart);
319 }
320
StopExtTimer(bool & isExtStop)321 ErrCode Service::StopExtTimer(bool &isExtStop)
322 {
323 return BService::serviceMock->StopExtTimer(isExtStop);
324 }
325
RefreshDataSize(int64_t totalsize)326 ErrCode Service::RefreshDataSize(int64_t totalsize)
327 {
328 return BService::serviceMock->RefreshDataSize(totalsize);
329 }
330
TimeOutCallback(wptr<Service> ptr,std::string bundleName)331 std::function<void()> Service::TimeOutCallback(wptr<Service> ptr, std::string bundleName)
332 {
333 return []() {};
334 }
335
SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo> &,std::vector<std::string> &,RestoreTypeEnum,std::string &)336 void Service::SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo>&, std::vector<std::string>&,
337 RestoreTypeEnum, std::string &) {}
338
SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo> &,std::vector<std::string> &,std::map<std::string,std::vector<BJsonUtil::BundleDetailInfo>> &,std::map<std::string,bool> &,RestoreTypeEnum,std::string &)339 void Service::SetCurrentSessProperties(std::vector<BJsonEntityCaps::BundleInfo>&, std::vector<std::string>&,
340 std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>>&, std::map<std::string, bool>&,
341 RestoreTypeEnum, std::string &) {}
342
SetCurrentSessProperties(BJsonEntityCaps::BundleInfo &,std::map<std::string,bool> &,const std::string &)343 void Service::SetCurrentSessProperties(BJsonEntityCaps::BundleInfo&, std::map<std::string, bool>&,
344 const std::string&) {}
345
ReleaseOnException()346 void Service::ReleaseOnException() {}
347
UpdateToRestoreBundleMap(const string & bundleName,const string & fileName)348 bool SvcRestoreDepsManager::UpdateToRestoreBundleMap(const string &bundleName, const string &fileName)
349 {
350 return BService::serviceMock->UpdateToRestoreBundleMap(bundleName, fileName);
351 }
352
OnBundleStarted(BError,sptr<SvcSessionManager>,const BundleName &)353 void Service::OnBundleStarted(BError, sptr<SvcSessionManager>, const BundleName&) {}
354
HandleExceptionOnAppendBundles(sptr<SvcSessionManager>,const vector<BundleName> &,const vector<BundleName> &)355 void Service::HandleExceptionOnAppendBundles(sptr<SvcSessionManager>, const vector<BundleName>&,
356 const vector<BundleName>&) {}
357
BundleBeginRadarReport(const std::string &,const ErrCode,const IServiceReverse::Scenario)358 void Service::BundleBeginRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {}
359
BundleEndRadarReport(const std::string &,const ErrCode,const IServiceReverse::Scenario)360 void Service::BundleEndRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {}
361
FileReadyRadarReport(const std::string &,const std::string &,const ErrCode,const IServiceReverse::Scenario)362 void Service::FileReadyRadarReport(const std::string&, const std::string&, const ErrCode,
363 const IServiceReverse::Scenario) {}
364
ExtensionConnectFailRadarReport(const std::string &,const ErrCode,const IServiceReverse::Scenario)365 void Service::ExtensionConnectFailRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {}
366
PermissionCheckFailRadar(const std::string &,const std::string &)367 void Service::PermissionCheckFailRadar(const std::string&, const std::string&) {}
368
OnStartResRadarReport(const std::vector<std::string> &,int32_t)369 void Service::OnStartResRadarReport(const std::vector<std::string>&, int32_t) {}
370
GetCallerName()371 std::string Service::GetCallerName()
372 {
373 return BService::serviceMock->GetCallerName();
374 }
375
IsReportBundleExecFail(const std::string & bundleName)376 bool Service::IsReportBundleExecFail(const std::string &bundleName)
377 {
378 return BService::serviceMock->IsReportBundleExecFail(bundleName);
379 }
380
ClearBundleRadarReport()381 void Service::ClearBundleRadarReport() {}
382
UpdateBundleRadarReport(const std::string &)383 void Service::UpdateBundleRadarReport(const std::string&) {}
384
IsReportFileReadyFail(const std::string & bundleName)385 bool Service::IsReportFileReadyFail(const std::string &bundleName)
386 {
387 return BService::serviceMock->IsReportFileReadyFail(bundleName);
388 }
389
ClearFileReadyRadarReport()390 void Service::ClearFileReadyRadarReport() {}
391
UpdateFailedBundles(const std::string &,BundleTaskInfo)392 void Service::UpdateFailedBundles(const std::string&, BundleTaskInfo) {}
393
ClearFailedBundles()394 void Service::ClearFailedBundles() {}
395
StartRunningTimer(const std::string &)396 void Service::StartRunningTimer(const std::string&) {}
397
GetSupportBackupBundleNames(vector<BJsonEntityCaps::BundleInfo> & bundleInfos,bool isIncBackup,const vector<std::string> & srcBundleNames)398 std::vector<std::string> Service::GetSupportBackupBundleNames(vector<BJsonEntityCaps::BundleInfo> &bundleInfos,
399 bool isIncBackup, const vector<std::string> &srcBundleNames)
400 {
401 return BService::serviceMock->GetSupportBackupBundleNames(bundleInfos, isIncBackup, srcBundleNames);
402 }
403
HandleCurBundleFileReady(const std::string & bundleName,const std::string & fileName,bool isIncBackup)404 ErrCode Service::HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup)
405 {
406 return BService::serviceMock->HandleCurBundleFileReady(bundleName, fileName, isIncBackup);
407 }
408
HandleCurAppDone(ErrCode errCode,const std::string & bundleName,bool isIncBackup)409 ErrCode Service::HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup)
410 {
411 return BService::serviceMock->HandleCurAppDone(errCode, bundleName, isIncBackup);
412 }
413
StartCurBundleBackupOrRestore(const std::string &)414 void Service::StartCurBundleBackupOrRestore(const std::string&) {}
415
GetLocalCapabilitiesForBundleInfos()416 UniqueFd Service::GetLocalCapabilitiesForBundleInfos()
417 {
418 return BService::serviceMock->GetLocalCapabilitiesForBundleInfos();
419 }
420
AppendBundles(const std::vector<std::string> &)421 void Service::AppendBundles(const std::vector<std::string>&) {}
422
GetBackupDataSize(bool isPreciseScan,vector<BIncrementalData> bundleNameList)423 ErrCode Service::GetBackupDataSize(bool isPreciseScan, vector<BIncrementalData> bundleNameList)
424 {
425 return BService::serviceMock->GetBackupDataSize(isPreciseScan, bundleNameList);
426 }
427 } // namespace OHOS::FileManagement::Backup
428
429 namespace OHOS::FileManagement::Backup {
430 using namespace std;
431 using namespace testing;
432 using namespace testing::ext;
433
434 constexpr int32_t SERVICE_ID = 5203;
435
436 class ServiceIncrementalTest : public testing::Test {
437 public:
438 static void SetUpTestCase(void);
439 static void TearDownTestCase();
SetUp()440 void SetUp() {};
TearDown()441 void TearDown() {};
442
443 static inline sptr<Service> service = nullptr;
444 static inline shared_ptr<BackupParaMock> param = nullptr;
445 static inline shared_ptr<BJsonUtilMock> jsonUtil = nullptr;
446 static inline shared_ptr<SvcSessionManagerMock> session = nullptr;
447 static inline shared_ptr<BundleMgrAdapterMock> bms = nullptr;
448 static inline sptr<SvcExtensionProxyMock> svcProxy = nullptr;
449 static inline sptr<SvcBackupConnectionMock> connect = nullptr;
450 static inline shared_ptr<SABackupConnectionMock> saConnect = nullptr;
451 static inline shared_ptr<IPCSkeletonMock> skeleton = nullptr;
452 static inline sptr<ServiceReverseProxyMock> srProxy = nullptr;
453 static inline shared_ptr<ServiceMock> srvMock = nullptr;
454 };
455
SetUpTestCase(void)456 void ServiceIncrementalTest::SetUpTestCase(void)
457 {
458 GTEST_LOG_(INFO) << "SetUpTestCase enter";
459 srvMock = make_shared<ServiceMock>();
460 ServiceMock::serviceMock = srvMock;
461 service = sptr(new Service(SERVICE_ID));
462 param = make_shared<BackupParaMock>();
463 BackupParaMock::backupPara = param;
464 jsonUtil = make_shared<BJsonUtilMock>();
465 BJsonUtilMock::jsonUtil = jsonUtil;
466 session = make_shared<SvcSessionManagerMock>();
467 SvcSessionManagerMock::sessionManager = session;
468 svcProxy = sptr(new SvcExtensionProxyMock());
469 bms = make_shared<BundleMgrAdapterMock>();
470 BundleMgrAdapterMock::bms = bms;
471 connect = sptr(new SvcBackupConnectionMock());
472 SvcBackupConnectionMock::connect = connect;
473 saConnect = make_shared<SABackupConnectionMock>();
474 SABackupConnectionMock::saConnect = saConnect;
475 skeleton = make_shared<IPCSkeletonMock>();
476 IPCSkeletonMock::skeleton = skeleton;
477 srProxy = sptr(new ServiceReverseProxyMock());
478 }
479
TearDownTestCase()480 void ServiceIncrementalTest::TearDownTestCase()
481 {
482 GTEST_LOG_(INFO) << "TearDownTestCase enter";
483 service = nullptr;
484 BackupParaMock::backupPara = nullptr;
485 param = nullptr;
486 BJsonUtilMock::jsonUtil = nullptr;
487 jsonUtil = nullptr;
488 SvcSessionManagerMock::sessionManager = nullptr;
489 session = nullptr;
490 svcProxy = nullptr;
491 BundleMgrAdapterMock::bms = nullptr;
492 bms = nullptr;
493 SvcBackupConnectionMock::connect = nullptr;
494 connect = nullptr;
495 SABackupConnectionMock::saConnect = nullptr;
496 saConnect = nullptr;
497 IPCSkeletonMock::skeleton = nullptr;
498 skeleton = nullptr;
499 srProxy = nullptr;
500 ServiceMock::serviceMock = nullptr;
501 srvMock = nullptr;
502 }
503
504 /**
505 * @tc.number: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000
506 * @tc.name: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000
507 * @tc.desc: 测试 GetLocalCapabilitiesIncremental 的正常/异常分支
508 * @tc.size: MEDIUM
509 * @tc.type: FUNC
510 * @tc.level Level 1
511 * @tc.require: issueIAKC3I
512 */
513 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000, TestSize.Level1)
514 {
515 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000";
516 try {
517 auto session_ = service->session_;
518 service->session_ = nullptr;
519 auto fd = service->GetLocalCapabilitiesIncremental({});
520 service->session_ = session_;
521 EXPECT_EQ(static_cast<int>(fd), -ENOENT);
522
523 service->isOccupyingSession_ = true;
524 fd = service->GetLocalCapabilitiesIncremental({});
525 EXPECT_EQ(static_cast<int>(fd), -ENOENT);
526
527 service->isOccupyingSession_ = false;
528 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
529 fd = service->GetLocalCapabilitiesIncremental({});
530 EXPECT_EQ(static_cast<int>(fd), -ENOENT);
531
532 vector<BJsonEntityCaps::BundleInfo> info;
533 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
534 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)).WillOnce(Return(0));
535 EXPECT_CALL(*bms, GetBundleInfosForIncremental(An<int32_t>(), An<const vector<BIncrementalData>&>()))
536 .WillOnce(Return(info));
537 fd = service->GetLocalCapabilitiesIncremental({});
538 EXPECT_TRUE(static_cast<int>(fd) > 0);
539 } catch (...) {
540 EXPECT_TRUE(false);
541 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetLocalCapabilitiesIncremental.";
542 }
543 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000";
544 }
545
546 /**
547 * @tc.number: SUB_ServiceIncremental_StartGetFdTask_0000
548 * @tc.name: SUB_ServiceIncremental_StartGetFdTask_0000
549 * @tc.desc: 测试 StartGetFdTask 的正常/异常分支
550 * @tc.size: MEDIUM
551 * @tc.type: FUNC
552 * @tc.level Level 1
553 * @tc.require: issueIAKC3I
554 */
555 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0000, TestSize.Level1)
556 {
557 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_StartGetFdTask_0000";
558 try {
559 service->StartGetFdTask("", nullptr);
560 EXPECT_TRUE(true);
561
562 auto session_ = service->session_;
563 service->session_ = nullptr;
564 EXPECT_THROW(service->StartGetFdTask("", service), BError);
565
566 service->session_ = session_;
567 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
568 EXPECT_THROW(service->StartGetFdTask("", service), BError);
569
570 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
571 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
572 EXPECT_THROW(service->StartGetFdTask("", service), BError);
573
574 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
575 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
576 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
577 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
578 EXPECT_CALL(*svcProxy, User0OnBackup()).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
579 service->StartGetFdTask("", service);
580 EXPECT_TRUE(true);
581
582 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
583 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
584 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
585 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
586 EXPECT_CALL(*svcProxy, User0OnBackup()).WillOnce(Return(ERR_OK));
587 service->StartGetFdTask("", service);
588 EXPECT_TRUE(true);
589 } catch (...) {
590 EXPECT_TRUE(false);
591 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by StartGetFdTask.";
592 }
593 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0000";
594 }
595
596 /**
597 * @tc.number: SUB_ServiceIncremental_StartGetFdTask_0100
598 * @tc.name: SUB_ServiceIncremental_StartGetFdTask_0100
599 * @tc.desc: 测试 StartGetFdTask 的正常/异常分支
600 * @tc.size: MEDIUM
601 * @tc.type: FUNC
602 * @tc.level Level 1
603 * @tc.require: issueIAKC3I
604 */
605 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0100, TestSize.Level1)
606 {
607 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_StartGetFdTask_0100";
608 try {
609 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
610 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
611 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
612 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
613 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
614 EXPECT_THROW(service->StartGetFdTask("", service), BError);
615
616 BJsonUtil::BundleDetailInfo bundleInfo;
617 vector<BJsonEntityCaps::BundleInfo> info;
618 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
619 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
620 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
621 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
622 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
623 EXPECT_CALL(*session, GetLastIncrementalTime(_)).WillOnce(Return(0));
624 EXPECT_CALL(*bms, GetBundleInfosForIncremental(An<const vector<BIncrementalData>&>(), An<int32_t>()))
625 .WillOnce(Return(info));
626 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
627 EXPECT_THROW(service->StartGetFdTask("", service), BError);
628 } catch (...) {
629 EXPECT_TRUE(false);
630 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by StartGetFdTask.";
631 }
632 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0100";
633 }
634
635 /**
636 * @tc.number: SUB_ServiceIncremental_RefreshBundleDataSize_0000
637 * @tc.name: SUB_ServiceIncremental_RefreshBundleDataSize_0000
638 * @tc.desc: 测试 RefreshBundleDataSize 的正常/异常分支
639 * @tc.size: MEDIUM
640 * @tc.type: FUNC
641 * @tc.level Level 1
642 * @tc.require: issueIAKC3I
643 */
644 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_RefreshBundleDataSize_0000, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_RefreshBundleDataSize_0000";
647 try {
648 service->RefreshBundleDataSize({}, "", nullptr);
649 EXPECT_TRUE(true);
650
651 auto session_ = service->session_;
652 service->session_ = nullptr;
653 service->RefreshBundleDataSize({}, "", service);
654 EXPECT_TRUE(true);
655
656 service->session_ = session_;
657 BJsonUtil::BundleDetailInfo bundleInfo;
658 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
659 service->RefreshBundleDataSize({}, "", service);
660 EXPECT_TRUE(true);
661
662 bundleInfo.bundleIndex = 0;
663 bundleInfo.bundleName = "bundleName";
664 vector<BJsonEntityCaps::BundleInfo> infos;
665 infos.emplace_back(BJsonEntityCaps::BundleInfo{.name = "bundleName", .appIndex = 0});
666 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
667 service->RefreshBundleDataSize(infos, "", service);
668 EXPECT_TRUE(true);
669
670 bundleInfo.bundleIndex = 1;
671 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
672 service->RefreshBundleDataSize(infos, "", service);
673 EXPECT_TRUE(true);
674
675 bundleInfo.bundleName = "appName";
676 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo));
677 service->RefreshBundleDataSize(infos, "", service);
678 EXPECT_TRUE(true);
679 } catch (...) {
680 EXPECT_TRUE(false);
681 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by RefreshBundleDataSize.";
682 }
683 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_RefreshBundleDataSize_0000";
684 }
685
686 /**
687 * @tc.number: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000
688 * @tc.name: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000
689 * @tc.desc: 测试 GetAppLocalListAndDoIncrementalBackup 的正常/异常分支
690 * @tc.size: MEDIUM
691 * @tc.type: FUNC
692 * @tc.level Level 1
693 * @tc.require: issueIAKC3I
694 */
695 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000, TestSize.Level1)
696 {
697 GTEST_LOG_(INFO) <<
698 "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000";
699 try {
700 auto session_ = service->session_;
701 service->session_ = nullptr;
702 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode());
703 service->session_ = session_;
704
705 service->isOccupyingSession_ = true;
706 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode());
707
708 service->isOccupyingSession_ = false;
709 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
710 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
711 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
712 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode());
713
714 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
715 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
716 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
717 EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::OK).GetCode());
718 } catch (...) {
719 EXPECT_TRUE(false);
720 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetAppLocalListAndDoIncrementalBackup.";
721 }
722 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000";
723 }
724
725 /**
726 * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0000
727 * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0000
728 * @tc.desc: 测试 InitIncrementalBackupSession 的正常/异常分支
729 * @tc.size: MEDIUM
730 * @tc.type: FUNC
731 * @tc.level Level 1
732 * @tc.require: issueIAKC3I
733 */
734 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0000, TestSize.Level1)
735 {
736 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0000";
737 try {
738 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
739 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode());
740
741 auto session_ = service->session_;
742 service->session_ = nullptr;
743 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
744 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode());
745 service->session_ = session_;
746
747 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
748 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
749 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
750 EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return(""));
751 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
752 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::OK).GetCode());
753
754 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
755 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
756 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
757 EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return(""));
758 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT)));
759 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_SESSION_CONFLICT).GetCode());
760
761 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
762 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
763 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
764 EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return(""));
765 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG)));
766 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode());
767
768 } catch (...) {
769 EXPECT_TRUE(false);
770 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession.";
771 }
772 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_InitIncrementalBackupSession_0000";
773 }
774
775 /**
776 * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0100
777 * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0100
778 * @tc.desc: 测试 InitIncrementalBackupSession with errMsg的正常/异常分支
779 * @tc.size: MEDIUM
780 * @tc.type: FUNC
781 * @tc.level Level 1
782 * @tc.require: issueIAKC3I
783 */
784 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0100, TestSize.Level1)
785 {
786 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0100";
787 try {
788 std::string errMsg;
789 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
790 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg),
791 BError(BError::Codes::SA_INVAL_ARG).GetCode());
792
793 auto session_ = service->session_;
794 service->session_ = nullptr;
795 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
796 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg),
797 BError(BError::Codes::SA_INVAL_ARG).GetCode());
798 service->session_ = session_;
799
800 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
801 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
802 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
803 EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return(""));
804 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
805 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), BError(BError::Codes::OK).GetCode());
806
807 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
808 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
809 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
810 EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return(""));
811 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT)));
812 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
813 EXPECT_CALL(*session, GetSessionCallerName()).WillOnce(Return(""));
814 EXPECT_CALL(*session, GetSessionActiveTime()).WillOnce(Return(""));
815 EXPECT_CALL(*jsonUtil, BuildInitSessionErrInfo(_, _, _)).WillOnce(Return(""));
816 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg),
817 BError(BError::Codes::SA_SESSION_CONFLICT).GetCode());
818
819 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
820 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
821 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
822 EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return(""));
823 EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG)));
824 EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg),
825 BError(BError::Codes::SA_INVAL_ARG).GetCode());
826 } catch (...) {
827 EXPECT_TRUE(false);
828 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession.";
829 }
830 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_InitIncrementalBackupSession_0100";
831 }
832
833 /**
834 * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000
835 * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000
836 * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支
837 * @tc.size: MEDIUM
838 * @tc.type: FUNC
839 * @tc.level Level 1
840 * @tc.require: issueIAKC3I
841 */
842 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000, TestSize.Level1)
843 {
844 GTEST_LOG_(INFO) <<
845 "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000";
846 try {
847 auto session_ = service->session_;
848 service->session_ = nullptr;
849 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode());
850 service->session_ = session_;
851
852 service->isOccupyingSession_ = true;
853 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode());
854
855 service->isOccupyingSession_ = false;
856 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
857 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode());
858
859 std::vector<std::string> supportBackupNames;
860 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
861 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
862 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
863 EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos));
864 EXPECT_CALL(*srvMock, GetSupportBackupBundleNames(_, _, _)).WillOnce(Return(supportBackupNames));
865 EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::OK).GetCode());
866 } catch (...) {
867 EXPECT_TRUE(false);
868 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppendBundlesIncrementalBackupSession.";
869 }
870 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000";
871 }
872
873 /**
874 * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100
875 * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100
876 * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支
877 * @tc.size: MEDIUM
878 * @tc.type: FUNC
879 * @tc.level Level 1
880 * @tc.require: issueIAKC3I
881 */
882 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100, TestSize.Level1)
883 {
884 GTEST_LOG_(INFO) <<
885 "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100";
886 try {
887 auto session_ = service->session_;
888 service->session_ = nullptr;
889 auto ret = service->AppendBundlesIncrementalBackupSession({}, {});
890 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
891 service->session_ = session_;
892
893 service->isOccupyingSession_ = true;
894 ret = service->AppendBundlesIncrementalBackupSession({}, {});
895 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
896
897 service->isOccupyingSession_ = false;
898 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
899 ret = service->AppendBundlesIncrementalBackupSession({}, {});
900 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
901
902 std::vector<std::string> supportBackupNames;
903 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
904 std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap;
905 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
906 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0));
907 EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap));
908 EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos));
909 EXPECT_CALL(*srvMock, GetSupportBackupBundleNames(_, _, _)).WillOnce(Return(supportBackupNames));
910 ret = service->AppendBundlesIncrementalBackupSession({}, {});
911 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
912 } catch (...) {
913 EXPECT_TRUE(false);
914 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppendBundlesIncrementalBackupSession.";
915 }
916 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100";
917 }
918
919 /**
920 * @tc.number: SUB_ServiceIncremental_PublishIncrementalFile_0000
921 * @tc.name: SUB_ServiceIncremental_PublishIncrementalFile_0000
922 * @tc.desc: 测试 PublishIncrementalFile 的正常/异常分支
923 * @tc.size: MEDIUM
924 * @tc.type: FUNC
925 * @tc.level Level 1
926 * @tc.require: issueIAKC3I
927 */
928 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishIncrementalFile_0000, TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_PublishIncrementalFile_0000";
931 try {
932 BFileInfo fileInfo;
933 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
934 auto ret = service->PublishIncrementalFile(fileInfo);
935 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
936
937 fileInfo.fileName = "test";
938 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
939 ret = service->PublishIncrementalFile(fileInfo);
940 EXPECT_EQ(ret, EPERM);
941
942 fileInfo.fileName.clear();
943 auto session_ = service->session_;
944 service->session_ = nullptr;
945 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
946 ret = service->PublishIncrementalFile(fileInfo);
947 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
948
949 service->session_ = session_;
950 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
951 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
952 ret = service->PublishIncrementalFile(fileInfo);
953 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
954
955 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
956 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
957 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
958 ret = service->PublishIncrementalFile(fileInfo);
959 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
960
961 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
962 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
963 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
964 EXPECT_CALL(*svcProxy, PublishIncrementalFile(_))
965 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
966 ret = service->PublishIncrementalFile(fileInfo);
967 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
968
969 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
970 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
971 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
972 EXPECT_CALL(*svcProxy, PublishIncrementalFile(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
973 ret = service->PublishIncrementalFile(fileInfo);
974 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
975 } catch (...) {
976 EXPECT_TRUE(false);
977 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by PublishIncrementalFile.";
978 }
979 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_PublishIncrementalFile_0000";
980 }
981
982 /**
983 * @tc.number: SUB_ServiceIncremental_PublishSAIncrementalFile_0000
984 * @tc.name: SUB_ServiceIncremental_PublishSAIncrementalFile_0000
985 * @tc.desc: 测试 PublishSAIncrementalFile 的正常/异常分支
986 * @tc.size: MEDIUM
987 * @tc.type: FUNC
988 * @tc.level Level 1
989 * @tc.require: issueIAKC3I
990 */
991 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishSAIncrementalFile_0000, TestSize.Level1)
992 {
993 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_PublishSAIncrementalFile_0000";
994 try {
995 BFileInfo fileInfo;
996 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
997 auto ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
998 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
999
1000 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1001 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1002 EXPECT_EQ(ret, BError(BError::Codes::SA_EXT_ERR_CALL).GetCode());
1003
1004 fileInfo.owner = "abc";
1005 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1006 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1007 EXPECT_EQ(ret, BError(BError::Codes::SA_EXT_ERR_CALL).GetCode());
1008
1009 fileInfo.owner = "123";
1010 shared_ptr<SABackupConnection> sa = nullptr;
1011 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1012 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1013 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1014 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1015
1016 sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr);
1017 EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1018 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa));
1019 EXPECT_CALL(*saConnect, CallRestoreSA(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1020 ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
1021 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1022 } catch (...) {
1023 EXPECT_TRUE(false);
1024 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by PublishSAIncrementalFile.";
1025 }
1026 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_PublishSAIncrementalFile_0000";
1027 }
1028
1029 /**
1030 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0000
1031 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0000
1032 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1033 * @tc.size: MEDIUM
1034 * @tc.type: FUNC
1035 * @tc.level Level 1
1036 * @tc.require: issueIAKC3I
1037 */
1038 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0000, TestSize.Level1)
1039 {
1040 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0000";
1041 try {
1042 string bundleName;
1043 string fileName;
1044 int32_t errCode = 0;
1045 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1046 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1047 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return());
1048 auto ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1049 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1050
1051 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1052 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1053 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1054 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1055 ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1056 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1057
1058 fileName = BConstants::EXT_BACKUP_MANAGE;
1059 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1060 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1061 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1062 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1063 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1064 ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1065 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1066 } catch (...) {
1067 EXPECT_TRUE(false);
1068 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1069 }
1070 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0000";
1071 }
1072
1073 /**
1074 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0100
1075 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0100
1076 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1077 * @tc.size: MEDIUM
1078 * @tc.type: FUNC
1079 * @tc.level Level 1
1080 * @tc.require: issueIAKC3I
1081 */
1082 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0100, TestSize.Level1)
1083 {
1084 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0100";
1085 try {
1086 string bundleName;
1087 string fileName;
1088 int32_t errCode = 0;
1089 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1090 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1091 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1092 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1093 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _))
1094 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1095 auto ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1096 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1097
1098 fileName = BConstants::EXT_BACKUP_MANAGE;
1099 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1100 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1101 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1102 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1103 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1104 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1105 ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1106 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1107 } catch (...) {
1108 EXPECT_TRUE(false);
1109 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1110 }
1111 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0100";
1112 }
1113
1114 /**
1115 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0200
1116 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0200
1117 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1118 * @tc.size: MEDIUM
1119 * @tc.type: FUNC
1120 * @tc.level Level 1
1121 * @tc.require: issueIAKC3I
1122 */
1123 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0200, TestSize.Level1)
1124 {
1125 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0200";
1126 try {
1127 string fileName;
1128 int32_t errCode = 0;
1129 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1130 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1131 auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1132 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1133
1134 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1135 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1136 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1137 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return());
1138 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1139 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1140
1141 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1142 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1143 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1144 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1145 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1146 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1147 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1148
1149 fileName = BConstants::EXT_BACKUP_MANAGE;
1150 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1151 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1152 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1153 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1154 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1155 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1156 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1157 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1158 } catch (...) {
1159 EXPECT_TRUE(false);
1160 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1161 }
1162 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0200";
1163 }
1164
1165 /**
1166 * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0300
1167 * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0300
1168 * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
1169 * @tc.size: MEDIUM
1170 * @tc.type: FUNC
1171 * @tc.level Level 1
1172 * @tc.require: issueIAKC3I
1173 */
1174 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0300, TestSize.Level1)
1175 {
1176 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0300";
1177 try {
1178 string fileName;
1179 int32_t errCode = 0;
1180 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1181 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1182 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1183 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1184 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1185 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _))
1186 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1187 auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1188 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1189
1190 fileName = BConstants::EXT_BACKUP_MANAGE;
1191 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1192 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1193 EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
1194 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1195 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1196 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1197 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1198 ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
1199 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1200 } catch (...) {
1201 EXPECT_TRUE(false);
1202 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
1203 }
1204 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0300";
1205 }
1206
1207 /**
1208 * @tc.number: SUB_ServiceIncremental_AppIncrementalDone_0000
1209 * @tc.name: SUB_ServiceIncremental_AppIncrementalDone_0000
1210 * @tc.desc: 测试 AppIncrementalDone 的正常/异常分支
1211 * @tc.size: MEDIUM
1212 * @tc.type: FUNC
1213 * @tc.level Level 1
1214 * @tc.require: issueIAKC3I
1215 */
1216 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, TestSize.Level1)
1217 {
1218 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalDone_0000";
1219 try {
1220 int32_t errCode = BError(BError::Codes::OK).GetCode();
1221 auto session_ = service->session_;
1222 service->session_ = nullptr;
1223 auto ret = service->AppIncrementalDone(errCode);
1224 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1225 service->session_ = session_;
1226
1227 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_))
1228 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1229 ret = service->AppIncrementalDone(errCode);
1230 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1231
1232 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1233 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1234 ret = service->AppIncrementalDone(errCode);
1235 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1236
1237 service->backupExtMutexMap_.clear();
1238 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1239 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1240 EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _))
1241 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1242 ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode());
1243 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1244
1245 service->backupExtMutexMap_.clear();
1246 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1247 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
1248 EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1249 ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode());
1250 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1251
1252 EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1253 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1254 EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1255 ret = service->AppIncrementalDone(errCode);
1256 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1257 } catch (...) {
1258 EXPECT_TRUE(false);
1259 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalDone.";
1260 }
1261 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalDone_0000";
1262 }
1263
1264 /**
1265 * @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0000
1266 * @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0000
1267 * @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支
1268 * @tc.size: MEDIUM
1269 * @tc.type: FUNC
1270 * @tc.level Level 1
1271 * @tc.require: issueIAKC3I
1272 */
1273 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0000, TestSize.Level1)
1274 {
1275 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0000";
1276 try {
1277 string bundleName;
1278 string fileName;
1279 auto session_ = service->session_;
1280 service->session_ = nullptr;
1281 auto ret = service->GetIncrementalFileHandle(bundleName, fileName);
1282 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1283 service->session_ = session_;
1284
1285 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1286 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1287 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1288
1289 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1290 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN));
1291 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1292 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1293
1294 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1295 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1296 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1297 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1298 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1299
1300 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1301 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1302 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1303 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1304 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1305 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1306 } catch (...) {
1307 EXPECT_TRUE(false);
1308 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle.";
1309 }
1310 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0000";
1311 }
1312
1313 /**
1314 * @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0100
1315 * @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0100
1316 * @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支
1317 * @tc.size: MEDIUM
1318 * @tc.type: FUNC
1319 * @tc.level Level 1
1320 * @tc.require: issueIAKC3I
1321 */
1322 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0100, TestSize.Level1)
1323 {
1324 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0100";
1325 try {
1326 string bundleName;
1327 string fileName;
1328 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1329 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1330 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1331 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1332 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
1333 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1334 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1335 EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
1336 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
1337 EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _))
1338 .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
1339 EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0));
1340 auto ret = service->GetIncrementalFileHandle(bundleName, fileName);
1341 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1342
1343 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1344 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1345 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1346 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1347 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
1348 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1349 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1350 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return());
1351 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1352 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1353
1354 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1355 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT));
1356 EXPECT_CALL(*srvMock, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(true));
1357 ret = service->GetIncrementalFileHandle(bundleName, fileName);
1358 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1359 } catch (...) {
1360 EXPECT_TRUE(false);
1361 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle.";
1362 }
1363 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0100";
1364 }
1365
1366 /**
1367 * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0000
1368 * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0000
1369 * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
1370 * @tc.size: MEDIUM
1371 * @tc.type: FUNC
1372 * @tc.level Level 1
1373 * @tc.require: issueIAKC3I
1374 */
1375 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, TestSize.Level1)
1376 {
1377 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0000";
1378 try {
1379 string bundleName;
1380 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1381 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1382 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1383
1384 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1385 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1386 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1387 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1388
1389 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1390 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1391 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1392 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1393
1394 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1395 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1396 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1397 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
1398 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1399 EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(0));
1400 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1401 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return());
1402 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1403
1404 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1405 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1406 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1407 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
1408 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1409 EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1));
1410 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1411 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return());
1412 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1413
1414 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1415 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1416 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1417 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false));
1418 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1419 } catch (...) {
1420 EXPECT_TRUE(false);
1421 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
1422 }
1423 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0000";
1424 }
1425
1426 /**
1427 * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0100
1428 * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0100
1429 * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
1430 * @tc.size: MEDIUM
1431 * @tc.type: FUNC
1432 * @tc.level Level 1
1433 * @tc.require: issueIAKC3I
1434 */
1435 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, TestSize.Level1)
1436 {
1437 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0100";
1438 try {
1439 string bundleName;
1440 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1441 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1442 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1443 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false));
1444 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1445
1446 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1447 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1448 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1449 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
1450 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false));
1451 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1452
1453 set<string> fileNameVec { "fileName" };
1454 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE))
1455 .WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1456 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1457 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1458 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
1459 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
1460 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1461 EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1462 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy));
1463 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return());
1464 EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return(""));
1465 EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
1466 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_))
1467 .WillOnce(Return(make_tuple(BError(BError::Codes::OK).GetCode(), UniqueFd(-1), UniqueFd(-1))));
1468 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return());
1469 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1470 } catch (...) {
1471 EXPECT_TRUE(false);
1472 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
1473 }
1474 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0100";
1475 }
1476
1477 /**
1478 * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0200
1479 * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0200
1480 * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
1481 * @tc.size: MEDIUM
1482 * @tc.type: FUNC
1483 * @tc.level Level 1
1484 * @tc.require: issueIAKC3I
1485 */
1486 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, TestSize.Level1)
1487 {
1488 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0200";
1489 try {
1490 string bundleName;
1491 set<string> fileNameVec { "fileName" };
1492 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE))
1493 .WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1494 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1495 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1496 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
1497 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
1498 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
1499 EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1500 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy));
1501 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return());
1502 EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return("1.0.0"));
1503 EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
1504 EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_))
1505 .WillOnce(Return(make_tuple(BError(BError::Codes::SA_INVAL_ARG).GetCode(), UniqueFd(-1), UniqueFd(-1))));
1506 EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return());
1507 EXPECT_TRUE(service->IncrementalBackup(bundleName));
1508
1509 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1510 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1511 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1512 EXPECT_FALSE(service->IncrementalBackup(bundleName));
1513 } catch (...) {
1514 EXPECT_TRUE(false);
1515 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
1516 }
1517 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0200";
1518 }
1519
1520 /**
1521 * @tc.number: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000
1522 * @tc.name: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000
1523 * @tc.desc: 测试 NotifyCallerCurAppIncrementDone 的正常/异常分支
1524 * @tc.size: MEDIUM
1525 * @tc.type: FUNC
1526 * @tc.level Level 1
1527 * @tc.require: issueIAKC3I
1528 */
1529 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000, TestSize.Level1)
1530 {
1531 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000";
1532 try {
1533 ErrCode errCode = 0;
1534 string callerName;
1535 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1536 service->NotifyCallerCurAppIncrementDone(errCode, callerName);
1537 EXPECT_TRUE(true);
1538
1539 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1540 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1541 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return());
1542 service->NotifyCallerCurAppIncrementDone(errCode, callerName);
1543 EXPECT_TRUE(true);
1544
1545 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1546 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
1547 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return());
1548 service->NotifyCallerCurAppIncrementDone(errCode, callerName);
1549 EXPECT_TRUE(true);
1550 } catch (...) {
1551 EXPECT_TRUE(false);
1552 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by NotifyCallerCurAppIncrementDone.";
1553 }
1554 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0200";
1555 }
1556
1557 /**
1558 * @tc.number: SUB_ServiceIncremental_SendUserIdToApp_0000
1559 * @tc.name: SUB_ServiceIncremental_SendUserIdToApp_0000
1560 * @tc.desc: 测试 SendUserIdToApp 的正常/异常分支
1561 * @tc.size: MEDIUM
1562 * @tc.type: FUNC
1563 * @tc.level Level 1
1564 * @tc.require: issueIAKC3I
1565 */
1566 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SendUserIdToApp_0000, TestSize.Level1)
1567 {
1568 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SendUserIdToApp_0000";
1569 try {
1570 string bundleName;
1571 int32_t userId = 100;
1572 auto session_ = service->session_;
1573 service->session_ = nullptr;
1574 service->SendUserIdToApp(bundleName, userId);
1575 service->session_ = session_;
1576 EXPECT_TRUE(true);
1577
1578 EXPECT_CALL(*jsonUtil, BuildBundleInfoJson(_, _)).WillOnce(Return(false));
1579 service->SendUserIdToApp(bundleName, userId);
1580 EXPECT_TRUE(true);
1581
1582 EXPECT_CALL(*jsonUtil, BuildBundleInfoJson(_, _)).WillOnce(Return(true));
1583 service->SendUserIdToApp(bundleName, userId);
1584 EXPECT_TRUE(true);
1585 } catch (...) {
1586 EXPECT_TRUE(false);
1587 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SendUserIdToApp.";
1588 }
1589 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SendUserIdToApp_0200";
1590 }
1591
1592 /**
1593 * @tc.number: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000
1594 * @tc.name: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000
1595 * @tc.desc: 测试 SetCurrentBackupSessProperties 的正常/异常分支
1596 * @tc.size: MEDIUM
1597 * @tc.type: FUNC
1598 * @tc.level Level 1
1599 * @tc.require: issueIAKC3I
1600 */
1601 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000, TestSize.Level1)
1602 {
1603 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000";
1604 try {
1605 vector<string> bundleNames { "bundleName" };
1606 int32_t userId = 100;
1607 vector<BJsonEntityCaps::BundleInfo> bundleInfos;
1608 auto session_ = service->session_;
1609 service->session_ = nullptr;
1610 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1611 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true);
1612 EXPECT_TRUE(true);
1613
1614 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
1615 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true);
1616 EXPECT_TRUE(true);
1617
1618 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1619 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, false);
1620 EXPECT_TRUE(true);
1621
1622 BJsonEntityCaps::BundleInfo bundleInfo;
1623 bundleInfo.name = "bundleName";
1624 bundleInfos.push_back(bundleInfo);
1625 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"));
1626 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1627 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, false);
1628 EXPECT_TRUE(true);
1629
1630 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName"));
1631 EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
1632 service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true);
1633 EXPECT_TRUE(true);
1634 service->session_ = session_;
1635 } catch (...) {
1636 EXPECT_TRUE(false);
1637 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SetCurrentBackupSessProperties.";
1638 }
1639 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetCurrentBackupSessProperties_0200";
1640 }
1641
1642 /**
1643 * @tc.number: SUB_ServiceIncremental_Release_0000
1644 * @tc.name: SUB_ServiceIncremental_Release_0000
1645 * @tc.desc: 测试 Release 的正常/异常分支
1646 * @tc.size: MEDIUM
1647 * @tc.type: FUNC
1648 * @tc.level Level 1
1649 * @tc.require: issueIAKC3I
1650 */
1651 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.Level1)
1652 {
1653 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Release_0000";
1654 try {
1655 auto session_ = service->session_;
1656 service->session_ = nullptr;
1657 auto ret = service->Release();
1658 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1659
1660 service->session_ = session_;
1661 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1662 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1663 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
1664 ret = service->Release();
1665 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1666
1667 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1668 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1669 EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0));
1670 ret = service->Release();
1671 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1672
1673 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1674 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1675 ret = service->Release();
1676 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
1677 } catch (...) {
1678 EXPECT_TRUE(false);
1679 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Release.";
1680 }
1681 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Release_0200";
1682 }
1683
1684 /**
1685 * @tc.number: SUB_ServiceIncremental_SetBundleIncDataInfo_0000
1686 * @tc.name: SUB_ServiceIncremental_SetBundleIncDataInfo_0000
1687 * @tc.desc: 测试 SetBundleIncDataInfo 的正常/异常分支
1688 * @tc.size: MEDIUM
1689 * @tc.type: FUNC
1690 * @tc.level Level 1
1691 * @tc.require: issueIAKC3I
1692 */
1693 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetBundleIncDataInfo_0000, TestSize.Level1)
1694 {
1695 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetBundleIncDataInfo_0000";
1696 try {
1697 vector<BIncrementalData> bundlesToBackup;
1698 vector<string> supportBundleNames;
1699 service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames);
1700 EXPECT_TRUE(true);
1701
1702 BIncrementalData data;
1703 data.bundleName = "bundleName";
1704 bundlesToBackup.push_back(data);
1705 service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames);
1706 EXPECT_TRUE(true);
1707
1708 supportBundleNames.emplace_back("bundleName");
1709 service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames);
1710 EXPECT_TRUE(true);
1711 } catch (...) {
1712 EXPECT_TRUE(false);
1713 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SetBundleIncDataInfo.";
1714 }
1715 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetBundleIncDataInfo_0200";
1716 }
1717
1718 /**
1719 * @tc.number: SUB_ServiceIncremental_CancelTask_0000
1720 * @tc.name: SUB_ServiceIncremental_CancelTask_0000
1721 * @tc.desc: 测试 CancelTask 的正常/异常分支
1722 * @tc.size: MEDIUM
1723 * @tc.type: FUNC
1724 * @tc.level Level 1
1725 * @tc.require: issueIAKC3I
1726 */
1727 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0000, TestSize.Level1)
1728 {
1729 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_CancelTask_0000";
1730 try {
1731 service->CancelTask("", nullptr);
1732 EXPECT_TRUE(true);
1733
1734 auto session_ = service->session_;
1735 service->session_ = nullptr;
1736 service->CancelTask("", service);
1737 service->session_ = session_;
1738 EXPECT_TRUE(true);
1739
1740 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1741 service->CancelTask("", service);
1742 EXPECT_TRUE(true);
1743
1744 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1745 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
1746 service->CancelTask("", service);
1747 EXPECT_TRUE(true);
1748
1749 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1750 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1751 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1752 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1753 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1754 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1755 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1756 service->CancelTask("", service);
1757 EXPECT_TRUE(true);
1758
1759 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1760 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1761 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1762 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1763 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1764 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1765 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
1766 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false));
1767 service->CancelTask("", service);
1768 EXPECT_TRUE(true);
1769 } catch (...) {
1770 EXPECT_TRUE(false);
1771 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by CancelTask.";
1772 }
1773 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_CancelTask_0000";
1774 }
1775
1776 /**
1777 * @tc.number: SUB_ServiceIncremental_CancelTask_0100
1778 * @tc.name: SUB_ServiceIncremental_CancelTask_0100
1779 * @tc.desc: 测试 CancelTask 的正常/异常分支
1780 * @tc.size: MEDIUM
1781 * @tc.type: FUNC
1782 * @tc.level Level 1
1783 * @tc.require: issueIAKC3I
1784 */
1785 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSize.Level1)
1786 {
1787 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_CancelTask_0100";
1788 try {
1789 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1790 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1791 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1792 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1793 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1794 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1795 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP))
1796 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1797 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
1798 service->CancelTask("", service);
1799 EXPECT_TRUE(true);
1800
1801 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1802 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1803 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1804 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1805 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1806 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1807 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1808 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false));
1809 service->CancelTask("", service);
1810 EXPECT_TRUE(true);
1811
1812 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
1813 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
1814 EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1815 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false));
1816 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false));
1817 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1818 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE))
1819 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
1820 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
1821 service->CancelTask("", service);
1822 EXPECT_TRUE(true);
1823 } catch (...) {
1824 EXPECT_TRUE(false);
1825 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by CancelTask.";
1826 }
1827 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_CancelTask_0100";
1828 }
1829
1830 /**
1831 * @tc.number: SUB_ServiceIncremental_Cancel_0000
1832 * @tc.name: SUB_ServiceIncremental_Cancel_0000
1833 * @tc.desc: 测试 Cancel 的正常/异常分支
1834 * @tc.size: MEDIUM
1835 * @tc.type: FUNC
1836 * @tc.level Level 1
1837 * @tc.require: issueIAKC3I
1838 */
1839 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Level1)
1840 {
1841 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000";
1842 try {
1843 string bundleName = "com.example.app2backup";
1844 BackupExtInfo info {};
1845 info.backupExtName = "com.example.app2backup";
1846 SvcSessionManager::Impl impl;
1847 int32_t result;
1848
1849 auto session_ = service->session_;
1850 service->session_ = nullptr;
1851 EXPECT_EQ(service->Cancel(bundleName, result),
1852 BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
1853 service->session_ = session_;
1854
1855 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1856 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
1857 auto ret = service->Cancel(bundleName, result);
1858 EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
1859
1860 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1861 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1862 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
1863 service->Cancel(bundleName, result);
1864 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
1865
1866 impl.backupExtNameMap.insert(make_pair(bundleName, info));
1867 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1868 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1869 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
1870 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN));
1871 service->Cancel(bundleName, result);
1872 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
1873
1874 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1875 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1876 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
1877 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN));
1878 service->Cancel(bundleName, result);
1879 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
1880 } catch (...) {
1881 EXPECT_TRUE(false);
1882 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel.";
1883 }
1884 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0000";
1885 }
1886
1887 /**
1888 * @tc.number: SUB_ServiceIncremental_Cancel_0100
1889 * @tc.name: SUB_ServiceIncremental_Cancel_0100
1890 * @tc.desc: 测试 Cancel 的正常/异常分支
1891 * @tc.size: MEDIUM
1892 * @tc.type: FUNC
1893 * @tc.level Level 1
1894 * @tc.require: issueIAKC3I
1895 */
1896 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0100, TestSize.Level1)
1897 {
1898 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000";
1899 try {
1900 string bundleName = "com.example.app2backup";
1901 BackupExtInfo info {};
1902 info.backupExtName = "com.example.app2backup";
1903 SvcSessionManager::Impl impl;
1904 int32_t result;
1905
1906 impl.backupExtNameMap.insert(make_pair(bundleName, info));
1907 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1908 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1909 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
1910 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START));
1911 service->Cancel(bundleName, result);
1912 EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
1913
1914 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
1915 EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1916 EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
1917 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
1918 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
1919 service->Cancel(bundleName, result);
1920 EXPECT_EQ(result, BError(BError::Codes::OK).GetCode());
1921 } catch (...) {
1922 EXPECT_TRUE(false);
1923 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel.";
1924 }
1925 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0100";
1926 }
1927
1928 /**
1929 * @tc.number: SUB_ServiceIncremental_GetExtensionMutex_0000
1930 * @tc.name: SUB_ServiceIncremental_GetExtensionMutex_0000
1931 * @tc.desc: 测试 GetExtensionMutex 的正常/异常分支
1932 * @tc.size: MEDIUM
1933 * @tc.type: FUNC
1934 * @tc.level Level 1
1935 * @tc.require: issueIAKC3I
1936 */
1937 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetExtensionMutex_0000, TestSize.Level1)
1938 {
1939 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetExtensionMutex_0000";
1940 try {
1941 BundleName bundleName = "bundleName";
1942 service->backupExtMutexMap_.clear();
1943 auto ret = service->GetExtensionMutex(bundleName);
1944 EXPECT_TRUE(ret != nullptr);
1945
1946 ret = service->GetExtensionMutex(bundleName);
1947 EXPECT_TRUE(ret != nullptr);
1948 service->backupExtMutexMap_.clear();
1949 } catch (...) {
1950 EXPECT_TRUE(false);
1951 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetExtensionMutex.";
1952 }
1953 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetExtensionMutex_0000";
1954 }
1955
1956 /**
1957 * @tc.number: SUB_ServiceIncremental_RemoveExtensionMutex_0000
1958 * @tc.name: SUB_ServiceIncremental_RemoveExtensionMutex_0000
1959 * @tc.desc: 测试 RemoveExtensionMutex 的正常/异常分支
1960 * @tc.size: MEDIUM
1961 * @tc.type: FUNC
1962 * @tc.level Level 1
1963 * @tc.require: issueIAKC3I
1964 */
1965 HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_RemoveExtensionMutex_0000, TestSize.Level1)
1966 {
1967 GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_RemoveExtensionMutex_0000";
1968 try {
1969 BundleName bundleName = "bundleName";
1970 service->backupExtMutexMap_.clear();
1971 service->RemoveExtensionMutex(bundleName);
1972 EXPECT_TRUE(true);
1973
1974 service->backupExtMutexMap_[bundleName] = nullptr;
1975 service->RemoveExtensionMutex(bundleName);
1976 EXPECT_TRUE(true);
1977 service->backupExtMutexMap_.clear();
1978 } catch (...) {
1979 EXPECT_TRUE(false);
1980 GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by RemoveExtensionMutex.";
1981 }
1982 GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_RemoveExtensionMutex_0000";
1983 }
1984 }