From ae28b87b13ed6f2241190b7deccef558d87bef57 Mon Sep 17 00:00:00 2001 From: wangpggg Date: Tue, 25 Feb 2025 14:57:39 +0800 Subject: [PATCH] add ut Signed-off-by: wangpeng --- .../app_gallery_service_connection.h | 2 +- .../module_ipc/service_incremental_test.cpp | 1203 ++++++++++++----- 2 files changed, 853 insertions(+), 352 deletions(-) diff --git a/services/backup_sa/include/module_app_gallery/app_gallery_service_connection.h b/services/backup_sa/include/module_app_gallery/app_gallery_service_connection.h index 30a2982e6..32c36d056 100644 --- a/services/backup_sa/include/module_app_gallery/app_gallery_service_connection.h +++ b/services/backup_sa/include/module_app_gallery/app_gallery_service_connection.h @@ -42,7 +42,7 @@ public: sptr GetRemoteObj(); private: - int32_t userId; + int32_t userId = 0; std::mutex conditionMutex_; std::condition_variable conditionVal_; std::mutex connectMutex; diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index 4a6ed74b6..2cd98147c 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -1,17 +1,17 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +* Copyright (c) 2024-2025 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ #include @@ -31,213 +31,301 @@ namespace OHOS::FileManagement::Backup { using namespace std; +class BService { +public: + virtual UniqueFd GetLocalCapabilities() = 0; + virtual ErrCode VerifyCallerAndGetCallerName(std::string&) = 0; + virtual ErrCode InitRestoreSession(sptr) = 0; + virtual ErrCode InitRestoreSession(sptr, std::string&) = 0; + virtual ErrCode InitBackupSession(sptr) = 0; + virtual ErrCode InitBackupSession(sptr, std::string&) = 0; + virtual ErrCode Start() = 0; + virtual ErrCode PublishFile(const BFileInfo&) = 0; + virtual ErrCode AppFileReady(const string&, UniqueFd, int32_t) = 0; + virtual ErrCode AppDone(ErrCode) = 0; + virtual ErrCode ServiceResultReport(const std::string, BackupRestoreScenario, ErrCode) = 0; + virtual ErrCode AppendBundlesRestoreSession(UniqueFd, const std::vector&, + const std::vector&, RestoreTypeEnum, int32_t) = 0; + virtual ErrCode AppendBundlesRestoreSession(UniqueFd, const std::vector&, RestoreTypeEnum, + int32_t) = 0; + virtual ErrCode AppendBundlesBackupSession(const std::vector&) = 0; + virtual ErrCode AppendBundlesDetailsBackupSession(const std::vector&, + const std::vector&) = 0; + virtual ErrCode Finish() = 0; + virtual ErrCode LaunchBackupExtension(const BundleName&) = 0; + virtual ErrCode LaunchBackupSAExtension(const BundleName&) = 0; + virtual ErrCode GetFileHandle(const string&, const string&) = 0; + virtual int Dump(int, const vector&) = 0; + virtual ErrCode VerifyCaller() = 0; + virtual ErrCode VerifyCaller(IServiceReverse::Scenario) = 0; + virtual int32_t GetUserIdDefault() = 0; + virtual ErrCode GetBackupInfo(BundleName&, std::string&) = 0; + virtual ErrCode UpdateTimer(BundleName&, uint32_t, bool&) = 0; + virtual ErrCode UpdateSendRate(std::string&, int32_t, bool&) = 0; + virtual ErrCode ReportAppProcessInfo(const std::string, BackupRestoreScenario) = 0; + virtual ErrCode StartExtTimer(bool&) = 0; + virtual ErrCode StartFwkTimer(bool&) = 0; + virtual ErrCode StopExtTimer(bool&) = 0; + virtual ErrCode RefreshDataSize(int64_t) = 0; + virtual std::string GetCallerName() = 0; + virtual bool IsReportBundleExecFail(const std::string&) = 0; + virtual bool IsReportFileReadyFail(const std::string&) = 0; + virtual std::vector GetSupportBackupBundleNames(vector&, bool, + const vector&) = 0; + virtual ErrCode HandleCurBundleFileReady(const std::string&, const std::string&, bool) = 0; + virtual ErrCode HandleCurAppDone(ErrCode, const std::string&, bool) = 0; + virtual UniqueFd GetLocalCapabilitiesForBundleInfos() = 0; + virtual ErrCode GetBackupDataSize(bool, vector) = 0; +public: + virtual bool UpdateToRestoreBundleMap(const string&, const string&) = 0; +public: + BService() = default; + virtual ~BService() = default; +public: + static inline std::shared_ptr serviceMock = nullptr; +}; + +class ServiceMock : public BService { +public: + MOCK_METHOD(UniqueFd, GetLocalCapabilities, ()); + MOCK_METHOD(ErrCode, VerifyCallerAndGetCallerName, (std::string&)); + MOCK_METHOD(ErrCode, InitRestoreSession, (sptr)); + MOCK_METHOD(ErrCode, InitRestoreSession, (sptr, std::string&)); + MOCK_METHOD(ErrCode, InitBackupSession, (sptr)); + MOCK_METHOD(ErrCode, InitBackupSession, ((sptr), std::string&)); + MOCK_METHOD(ErrCode, Start, ()); + MOCK_METHOD(ErrCode, PublishFile, (const BFileInfo&)); + MOCK_METHOD(ErrCode, AppFileReady, (const string&, UniqueFd, int32_t)); + MOCK_METHOD(ErrCode, AppDone, (ErrCode)); + MOCK_METHOD(ErrCode, ServiceResultReport, (const std::string, BackupRestoreScenario, ErrCode)); + MOCK_METHOD(ErrCode, AppendBundlesRestoreSession, (UniqueFd, (const std::vector&), + (const std::vector&), RestoreTypeEnum, int32_t)); + MOCK_METHOD(ErrCode, AppendBundlesRestoreSession, (UniqueFd, (const std::vector&), RestoreTypeEnum, + int32_t)); + MOCK_METHOD(ErrCode, AppendBundlesBackupSession, (const std::vector&)); + MOCK_METHOD(ErrCode, AppendBundlesDetailsBackupSession, ((const std::vector&), + (const std::vector&))); + MOCK_METHOD(ErrCode, Finish, ()); + MOCK_METHOD(ErrCode, LaunchBackupExtension, (const BundleName&)); + MOCK_METHOD(ErrCode, LaunchBackupSAExtension, (const BundleName&)); + MOCK_METHOD(ErrCode, GetFileHandle, (const string&, const string&)); + MOCK_METHOD(int, Dump, (int, const vector&)); + MOCK_METHOD(ErrCode, VerifyCaller, ()); + MOCK_METHOD(ErrCode, VerifyCaller, (IServiceReverse::Scenario)); + MOCK_METHOD(int32_t, GetUserIdDefault, ()); + MOCK_METHOD(ErrCode, GetBackupInfo, (BundleName&, std::string&)); + MOCK_METHOD(ErrCode, UpdateTimer, (BundleName&, uint32_t, bool&)); + MOCK_METHOD(ErrCode, UpdateSendRate, (std::string&, int32_t, bool&)); + MOCK_METHOD(ErrCode, ReportAppProcessInfo, (const std::string, BackupRestoreScenario)); + MOCK_METHOD(ErrCode, StartExtTimer, (bool&)); + MOCK_METHOD(ErrCode, StartFwkTimer, (bool&)); + MOCK_METHOD(ErrCode, StopExtTimer, (bool&)); + MOCK_METHOD(ErrCode, RefreshDataSize, (int64_t)); + MOCK_METHOD(std::string, GetCallerName, ()); + MOCK_METHOD(bool, IsReportBundleExecFail, (const std::string&)); + MOCK_METHOD(bool, IsReportFileReadyFail, (const std::string&)); + MOCK_METHOD(std::vector, GetSupportBackupBundleNames, ((vector&), bool, + (const vector&))); + MOCK_METHOD(ErrCode, HandleCurBundleFileReady, (const std::string&, const std::string&, bool)); + MOCK_METHOD(ErrCode, HandleCurAppDone, (ErrCode, const std::string&, bool)); + MOCK_METHOD(UniqueFd, GetLocalCapabilitiesForBundleInfos, ()); + MOCK_METHOD(ErrCode, GetBackupDataSize, (bool, vector)); +public: + MOCK_METHOD(bool, UpdateToRestoreBundleMap, (const string&, const string&)); +}; + void Service::OnStart() {} void Service::OnStop() {} UniqueFd Service::GetLocalCapabilities() { - return UniqueFd(-1); + return BService::serviceMock->GetLocalCapabilities(); } -void Service::StopAll(const wptr &obj, bool force) {} +void Service::StopAll(const wptr&, bool) {} ErrCode Service::VerifyCallerAndGetCallerName(std::string &bundleName) { - return BError(BError::Codes::OK); + return BService::serviceMock->VerifyCallerAndGetCallerName(bundleName); } ErrCode Service::InitRestoreSession(sptr remote) { - return BError(BError::Codes::OK); + return BService::serviceMock->InitRestoreSession(remote); } ErrCode Service::InitRestoreSession(sptr remote, std::string &errMsg) { - return BError(BError::Codes::OK); + return BService::serviceMock->InitRestoreSession(remote, errMsg); } ErrCode Service::InitBackupSession(sptr remote) { - return BError(BError::Codes::OK); + return BService::serviceMock->InitBackupSession(remote); } ErrCode Service::InitBackupSession(sptr remote, std::string &errMsg) { - return BError(BError::Codes::OK); + return BService::serviceMock->InitBackupSession(remote, errMsg); } ErrCode Service::Start() { - return BError(BError::Codes::OK); + return BService::serviceMock->Start(); } ErrCode Service::PublishFile(const BFileInfo &fileInfo) { - return BError(BError::Codes::OK); + return BService::serviceMock->PublishFile(fileInfo); } ErrCode Service::AppFileReady(const string &fileName, UniqueFd fd, int32_t errCode) { - return BError(BError::Codes::OK); + return BService::serviceMock->AppFileReady(fileName, move(fd), errCode); } ErrCode Service::AppDone(ErrCode errCode) { - return BError(BError::Codes::OK); + return BService::serviceMock->AppDone(errCode); } -ErrCode Service::ServiceResultReport(const std::string restoreRetInfo, - BackupRestoreScenario sennario, ErrCode errCode) +ErrCode Service::ServiceResultReport(const std::string restoreRetInfo, BackupRestoreScenario sennario, ErrCode errCode) { - return BError(BError::Codes::OK); + return BService::serviceMock->ServiceResultReport(restoreRetInfo, sennario, errCode); } ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, const std::vector &bundleNames, const std::vector &detailInfos, RestoreTypeEnum restoreType, int32_t userId) { - return BError(BError::Codes::OK); + return BService::serviceMock->AppendBundlesRestoreSession(move(fd), bundleNames, detailInfos, restoreType, userId); } -ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, - const std::vector &bundleNames, - RestoreTypeEnum restoreType, - int32_t userId) +ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, const std::vector &bundleNames, + RestoreTypeEnum restoreType, int32_t userId) { - return BError(BError::Codes::OK); + return BService::serviceMock->AppendBundlesRestoreSession(move(fd), bundleNames, restoreType, userId); } ErrCode Service::AppendBundlesBackupSession(const std::vector &bundleNames) { - return BError(BError::Codes::OK); + return BService::serviceMock->AppendBundlesBackupSession(bundleNames); } ErrCode Service::AppendBundlesDetailsBackupSession(const std::vector &bundleNames, const std::vector &bundleInfos) { - return BError(BError::Codes::OK); + return BService::serviceMock->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); } ErrCode Service::Finish() { - return BError(BError::Codes::OK); + return BService::serviceMock->Finish(); } ErrCode Service::LaunchBackupExtension(const BundleName &bundleName) { - return BError(BError::Codes::OK); + return BService::serviceMock->LaunchBackupExtension(bundleName); } ErrCode Service::LaunchBackupSAExtension(const BundleName &bundleName) { - return BError(BError::Codes::OK); + return BService::serviceMock->LaunchBackupSAExtension(bundleName); } ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName) { - return BError(BError::Codes::OK); + return BService::serviceMock->GetFileHandle(bundleName, fileName); } -void Service::OnBackupExtensionDied(const string &&bundleName, bool isCleanCalled) {} +void Service::OnBackupExtensionDied(const string&&, bool) {} -void Service::ExtConnectDied(const string &callName) {} +void Service::ExtConnectDied(const string&) {} -void Service::ExtStart(const string &bundleName) {} +void Service::ExtStart(const string&) {} int Service::Dump(int fd, const vector &args) { - return 0; + return BService::serviceMock->Dump(fd, args); } -void Service::ExtConnectFailed(const string &bundleName, ErrCode ret) -{ - GTEST_LOG_(INFO) << "ExtConnectFailed is OK"; -} +void Service::ExtConnectFailed(const string&, ErrCode) {} -void Service::ExtConnectDone(string bundleName) {} +void Service::ExtConnectDone(string) {} -void Service::ClearSessionAndSchedInfo(const string &bundleName) {} +void Service::ClearSessionAndSchedInfo(const string&) {} ErrCode Service::VerifyCaller() { - return BError(BError::Codes::OK); + return BService::serviceMock->VerifyCaller(); } ErrCode Service::VerifyCaller(IServiceReverse::Scenario scenario) { - return BError(BError::Codes::OK); + return BService::serviceMock->VerifyCaller(scenario); } int32_t Service::GetUserIdDefault() { - return 0; + return BService::serviceMock->GetUserIdDefault(); } -void Service::OnAllBundlesFinished(ErrCode errCode) {} +void Service::OnAllBundlesFinished(ErrCode) {} void Service::OnStartSched() {} -void Service::SendStartAppGalleryNotify(const BundleName &bundleName) {} +void Service::SendStartAppGalleryNotify(const BundleName&) {} void Service::SessionDeactive() {} ErrCode Service::GetBackupInfo(BundleName &bundleName, std::string &result) { - return BError(BError::Codes::OK); + return BService::serviceMock->GetBackupInfo(bundleName, result); } ErrCode Service::UpdateTimer(BundleName &bundleName, uint32_t timeOut, bool &result) { - return BError(BError::Codes::OK); + return BService::serviceMock->UpdateTimer(bundleName, timeOut, result); } ErrCode Service::UpdateSendRate(std::string &bundleName, int32_t sendRate, bool &result) { - return BError(BError::Codes::OK); + return BService::serviceMock->UpdateSendRate(bundleName, sendRate, result); } -void Service::OnSABackup(const std::string &bundleName, - const int &fd, - const std::string &result, - const ErrCode &errCode) -{ -} +void Service::OnSABackup(const std::string&, const int&, const std::string&, const ErrCode&) {} -void Service::OnSARestore(const std::string &bundleName, const std::string &result, const ErrCode &errCode) {} +void Service::OnSARestore(const std::string&, const std::string&, const ErrCode&) {} -void Service::NotifyCallerCurAppDone(ErrCode errCode, const std::string &callerName) {} +void Service::NotifyCallerCurAppDone(ErrCode, const std::string&) {} -void Service::SendEndAppGalleryNotify(const BundleName &bundleName) -{ -} +void Service::SendEndAppGalleryNotify(const BundleName&) {} -void Service::NoticeClientFinish(const string &bundleName, ErrCode errCode) -{ -} +void Service::NoticeClientFinish(const string&, ErrCode) {} ErrCode Service::ReportAppProcessInfo(const std::string processInfo, BackupRestoreScenario sennario) { - return BError(BError::Codes::OK); + return BService::serviceMock->ReportAppProcessInfo(processInfo, sennario); } ErrCode Service::StartExtTimer(bool &isExtStart) { - return BError(BError::Codes::OK); + return BService::serviceMock->StartExtTimer(isExtStart); } ErrCode Service::StartFwkTimer(bool &isFwkStart) { - return BError(BError::Codes::OK); + return BService::serviceMock->StartFwkTimer(isFwkStart); } ErrCode Service::StopExtTimer(bool &isExtStop) { - return BError(BError::Codes::OK); + return BService::serviceMock->StopExtTimer(isExtStop); } ErrCode Service::RefreshDataSize(int64_t totalsize) { - return BError(BError::Codes::OK); + return BService::serviceMock->RefreshDataSize(totalsize); } std::function Service::TimeOutCallback(wptr ptr, std::string bundleName) @@ -257,86 +345,84 @@ void Service::SetCurrentSessProperties(BJsonEntityCaps::BundleInfo&, std::mapUpdateToRestoreBundleMap(bundleName, fileName); } -void Service::OnBundleStarted(BError error, sptr session, const BundleName &bundleName) {} +void Service::OnBundleStarted(BError, sptr, const BundleName&) {} -void Service::HandleExceptionOnAppendBundles(sptr session, - const vector &appendBundleNames, const vector &restoreBundleNames) {} +void Service::HandleExceptionOnAppendBundles(sptr, const vector&, + const vector&) {} -void Service::BundleBeginRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} +void Service::BundleBeginRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {} -void Service::BundleEndRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} +void Service::BundleEndRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {} -void Service::FileReadyRadarReport(const std::string &bundleName, const std::string &fileName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} +void Service::FileReadyRadarReport(const std::string&, const std::string&, const ErrCode, + const IServiceReverse::Scenario) {} -void Service::ExtensionConnectFailRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} +void Service::ExtensionConnectFailRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {} -void Service::PermissionCheckFailRadar(const std::string &info, const std::string &func) {} +void Service::PermissionCheckFailRadar(const std::string&, const std::string&) {} -void Service::OnStartResRadarReport(const std::vector &bundleNameList, int32_t stage) {} +void Service::OnStartResRadarReport(const std::vector&, int32_t) {} std::string Service::GetCallerName() { - return ""; + return BService::serviceMock->GetCallerName(); } bool Service::IsReportBundleExecFail(const std::string &bundleName) { - return true; + return BService::serviceMock->IsReportBundleExecFail(bundleName); } void Service::ClearBundleRadarReport() {} -void Service::UpdateBundleRadarReport(const std::string &bundleName) {} +void Service::UpdateBundleRadarReport(const std::string&) {} bool Service::IsReportFileReadyFail(const std::string &bundleName) { - return true; + return BService::serviceMock->IsReportFileReadyFail(bundleName); } void Service::ClearFileReadyRadarReport() {} -void Service::UpdateFailedBundles(const std::string &bundleName, BundleTaskInfo taskInfo) {} +void Service::UpdateFailedBundles(const std::string&, BundleTaskInfo) {} void Service::ClearFailedBundles() {} -void Service::StartRunningTimer(const std::string &bundleName) {} +void Service::StartRunningTimer(const std::string&) {} -std::vector Service::GetSupportBackupBundleNames(vector&, bool, - const vector&) +std::vector Service::GetSupportBackupBundleNames(vector &bundleInfos, + bool isIncBackup, const vector &srcBundleNames) { - return {}; + return BService::serviceMock->GetSupportBackupBundleNames(bundleInfos, isIncBackup, srcBundleNames); } -ErrCode Service::HandleCurBundleFileReady(const std::string&, const std::string&, bool) +ErrCode Service::HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup) { - return BError(BError::Codes::OK); + return BService::serviceMock->HandleCurBundleFileReady(bundleName, fileName, isIncBackup); } -ErrCode Service::HandleCurAppDone(ErrCode errCode, const std::string&, bool) +ErrCode Service::HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup) { - return BError(BError::Codes::OK); + return BService::serviceMock->HandleCurAppDone(errCode, bundleName, isIncBackup); } void Service::StartCurBundleBackupOrRestore(const std::string&) {} UniqueFd Service::GetLocalCapabilitiesForBundleInfos() { - return UniqueFd(-1); + return BService::serviceMock->GetLocalCapabilitiesForBundleInfos(); } -void Service::AppendBundles(const std::vector &bundleNames) {} +void Service::AppendBundles(const std::vector&) {} + ErrCode Service::GetBackupDataSize(bool isPreciseScan, vector bundleNameList) { - return BError(BError::Codes::OK); + return BService::serviceMock->GetBackupDataSize(isPreciseScan, bundleNameList); } } // namespace OHOS::FileManagement::Backup @@ -364,11 +450,14 @@ public: static inline shared_ptr saConnect = nullptr; static inline shared_ptr skeleton = nullptr; static inline sptr srProxy = nullptr; + static inline shared_ptr srvMock = nullptr; }; void ServiceIncrementalTest::SetUpTestCase(void) { GTEST_LOG_(INFO) << "SetUpTestCase enter"; + srvMock = make_shared(); + ServiceMock::serviceMock = srvMock; service = sptr(new Service(SERVICE_ID)); param = make_shared(); BackupParaMock::backupPara = param; @@ -408,17 +497,19 @@ void ServiceIncrementalTest::TearDownTestCase() IPCSkeletonMock::skeleton = nullptr; skeleton = nullptr; srProxy = nullptr; + ServiceMock::serviceMock = nullptr; + srvMock = nullptr; } /** - * @tc.number: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000 - * @tc.name: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000 - * @tc.desc: 测试 GetLocalCapabilitiesIncremental 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000 +* @tc.name: SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000 +* @tc.desc: 测试 GetLocalCapabilitiesIncremental 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetLocalCapabilitiesIncremental_0000"; @@ -428,6 +519,23 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetLocalCapabilitiesIncr auto fd = service->GetLocalCapabilitiesIncremental({}); service->session_ = session_; EXPECT_EQ(static_cast(fd), -ENOENT); + + service->isOccupyingSession_ = true; + fd = service->GetLocalCapabilitiesIncremental({}); + EXPECT_EQ(static_cast(fd), -ENOENT); + + service->isOccupyingSession_ = false; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode())); + fd = service->GetLocalCapabilitiesIncremental({}); + EXPECT_EQ(static_cast(fd), -ENOENT); + + vector info; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*bms, GetBundleInfosForIncremental(An(), An&>())) + .WillOnce(Return(info)); + fd = service->GetLocalCapabilitiesIncremental({}); + EXPECT_TRUE(static_cast(fd) > 0); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetLocalCapabilitiesIncremental."; @@ -436,14 +544,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetLocalCapabilitiesIncr } /** - * @tc.number: SUB_ServiceIncremental_StartGetFdTask_0000 - * @tc.name: SUB_ServiceIncremental_StartGetFdTask_0000 - * @tc.desc: 测试 StartGetFdTask 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_StartGetFdTask_0000 +* @tc.name: SUB_ServiceIncremental_StartGetFdTask_0000 +* @tc.desc: 测试 StartGetFdTask 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_StartGetFdTask_0000"; @@ -478,32 +586,112 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0000, Tes EXPECT_CALL(*svcProxy, User0OnBackup()).WillOnce(Return(ERR_OK)); service->StartGetFdTask("", service); EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by StartGetFdTask."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0000"; +} + +/** +* @tc.number: SUB_ServiceIncremental_StartGetFdTask_0100 +* @tc.name: SUB_ServiceIncremental_StartGetFdTask_0100 +* @tc.desc: 测试 StartGetFdTask 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_StartGetFdTask_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_StartGetFdTask_0100"; + try { + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); + EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false)); + EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); + EXPECT_THROW(service->StartGetFdTask("", service), BError); + BJsonUtil::BundleDetailInfo bundleInfo; vector info; EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false)); + EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetLastIncrementalTime(_)).WillOnce(Return(0)); EXPECT_CALL(*bms, GetBundleInfosForIncremental(An&>(), An())) .WillOnce(Return(info)); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo)); EXPECT_THROW(service->StartGetFdTask("", service), BError); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by StartGetFdTask."; } - GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0000"; + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_StartGetFdTask_0100"; +} + +/** +* @tc.number: SUB_ServiceIncremental_RefreshBundleDataSize_0000 +* @tc.name: SUB_ServiceIncremental_RefreshBundleDataSize_0000 +* @tc.desc: 测试 RefreshBundleDataSize 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_RefreshBundleDataSize_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_RefreshBundleDataSize_0000"; + try { + service->RefreshBundleDataSize({}, "", nullptr); + EXPECT_TRUE(true); + + auto session_ = service->session_; + service->session_ = nullptr; + service->RefreshBundleDataSize({}, "", service); + EXPECT_TRUE(true); + + service->session_ = session_; + BJsonUtil::BundleDetailInfo bundleInfo; + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo)); + service->RefreshBundleDataSize({}, "", service); + EXPECT_TRUE(true); + + bundleInfo.bundleIndex = 0; + bundleInfo.bundleName = "bundleName"; + vector infos; + infos.emplace_back(BJsonEntityCaps::BundleInfo{.name = "bundleName", .appIndex = 0}); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo)); + service->RefreshBundleDataSize(infos, "", service); + EXPECT_TRUE(true); + + bundleInfo.bundleIndex = 1; + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo)); + service->RefreshBundleDataSize(infos, "", service); + EXPECT_TRUE(true); + + bundleInfo.bundleName = "appName"; + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(bundleInfo)); + service->RefreshBundleDataSize(infos, "", service); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by RefreshBundleDataSize."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_RefreshBundleDataSize_0000"; } /** - * @tc.number: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000 - * @tc.name: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000 - * @tc.desc: 测试 GetAppLocalListAndDoIncrementalBackup 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000 +* @tc.name: SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000 +* @tc.desc: 测试 GetAppLocalListAndDoIncrementalBackup 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetAppLocalListAndDoIncrementalBackup_0000, TestSize.Level1) { GTEST_LOG_(INFO) << @@ -513,6 +701,20 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetAppLocalListAndDoIncr service->session_ = nullptr; EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; + + service->isOccupyingSession_ = true; + EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->isOccupyingSession_ = false; + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + EXPECT_EQ(service->GetAppLocalListAndDoIncrementalBackup(), BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetAppLocalListAndDoIncrementalBackup."; @@ -521,27 +723,48 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetAppLocalListAndDoIncr } /** - * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0000 - * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0000 - * @tc.desc: 测试 InitIncrementalBackupSession 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0000 +* @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0000 +* @tc.desc: 测试 InitIncrementalBackupSession 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0000"; try { + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode()); + auto session_ = service->session_; service->session_ = nullptr; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; - EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); - EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return("")); EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK))); EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::OK).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return("")); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT))); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_SESSION_CONFLICT).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return("")); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr), BError(BError::Codes::SA_INVAL_ARG).GetCode()); + } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession."; @@ -550,29 +773,56 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSes } /** - * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0100 - * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0100 - * @tc.desc: 测试 InitIncrementalBackupSession with errMsg的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0100 +* @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0100 +* @tc.desc: 测试 InitIncrementalBackupSession with errMsg的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0100"; try { std::string errMsg; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), + BError(BError::Codes::SA_INVAL_ARG).GetCode()); + auto session_ = service->session_; service->session_ = nullptr; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; - EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); - EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return("")); EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK))); EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), BError(BError::Codes::OK).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return("")); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT))); + EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); + EXPECT_CALL(*session, GetSessionCallerName()).WillOnce(Return("")); + EXPECT_CALL(*session, GetSessionActiveTime()).WillOnce(Return("")); + EXPECT_CALL(*jsonUtil, BuildInitSessionErrInfo(_, _, _)).WillOnce(Return("")); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), + BError(BError::Codes::SA_SESSION_CONFLICT).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + EXPECT_CALL(*srvMock, GetCallerName()).WillOnce(Return("")); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), + BError(BError::Codes::SA_INVAL_ARG).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession."; @@ -581,14 +831,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSes } /** - * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000 - * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000 - * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000 +* @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000 +* @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000, TestSize.Level1) { GTEST_LOG_(INFO) << @@ -603,9 +853,15 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncremental EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->isOccupyingSession_ = false; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + std::vector supportBackupNames; vector bundleInfos; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos)); + EXPECT_CALL(*srvMock, GetSupportBackupBundleNames(_, _, _)).WillOnce(Return(supportBackupNames)); EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); @@ -615,14 +871,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncremental } /** - * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100 - * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100 - * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100 +* @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100 +* @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100, TestSize.Level1) { GTEST_LOG_(INFO) << @@ -639,11 +895,18 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncremental EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->isOccupyingSession_ = false; - map> bundleNameDetailMap; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + ret = service->AppendBundlesIncrementalBackupSession({}, {}); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + std::vector supportBackupNames; vector bundleInfos; + std::map> bundleNameDetailMap; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap)); EXPECT_CALL(*bms, GetBundleInfosForAppendBundles(_, _)).WillOnce(Return(bundleInfos)); + EXPECT_CALL(*srvMock, GetSupportBackupBundleNames(_, _, _)).WillOnce(Return(supportBackupNames)); ret = service->AppendBundlesIncrementalBackupSession({}, {}); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -654,40 +917,48 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncremental } /** - * @tc.number: SUB_ServiceIncremental_PublishIncrementalFile_0000 - * @tc.name: SUB_ServiceIncremental_PublishIncrementalFile_0000 - * @tc.desc: 测试 PublishIncrementalFile 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_PublishIncrementalFile_0000 +* @tc.name: SUB_ServiceIncremental_PublishIncrementalFile_0000 +* @tc.desc: 测试 PublishIncrementalFile 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishIncrementalFile_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_PublishIncrementalFile_0000"; try { BFileInfo fileInfo; - fileInfo.fileName = "test"; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); auto ret = service->PublishIncrementalFile(fileInfo); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + fileInfo.fileName = "test"; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + ret = service->PublishIncrementalFile(fileInfo); EXPECT_EQ(ret, EPERM); fileInfo.fileName.clear(); auto session_ = service->session_; service->session_ = nullptr; - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->PublishIncrementalFile(fileInfo); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); ret = service->PublishIncrementalFile(fileInfo); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); ret = service->PublishIncrementalFile(fileInfo); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*svcProxy, PublishIncrementalFile(_)) @@ -695,6 +966,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishIncrementalFile_0 ret = service->PublishIncrementalFile(fileInfo); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*svcProxy, PublishIncrementalFile(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); @@ -708,33 +980,41 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishIncrementalFile_0 } /** - * @tc.number: SUB_ServiceIncremental_PublishSAIncrementalFile_0000 - * @tc.name: SUB_ServiceIncremental_PublishSAIncrementalFile_0000 - * @tc.desc: 测试 PublishSAIncrementalFile 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_PublishSAIncrementalFile_0000 +* @tc.name: SUB_ServiceIncremental_PublishSAIncrementalFile_0000 +* @tc.desc: 测试 PublishSAIncrementalFile 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishSAIncrementalFile_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_PublishSAIncrementalFile_0000"; try { BFileInfo fileInfo; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); auto ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1)); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1)); EXPECT_EQ(ret, BError(BError::Codes::SA_EXT_ERR_CALL).GetCode()); fileInfo.owner = "abc"; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1)); EXPECT_EQ(ret, BError(BError::Codes::SA_EXT_ERR_CALL).GetCode()); fileInfo.owner = "123"; shared_ptr sa = nullptr; + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1)); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); sa = make_shared(nullptr, nullptr, nullptr, nullptr); + EXPECT_CALL(*srvMock, VerifyCaller()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*saConnect, CallRestoreSA(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->PublishSAIncrementalFile(fileInfo, UniqueFd(-1)); @@ -747,31 +1027,32 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishSAIncrementalFile } /** - * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0000 - * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0000 - * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0000 +* @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0000 +* @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0000"; try { + string bundleName; string fileName; int32_t errCode = 0; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); - auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + auto ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); fileName = BConstants::EXT_BACKUP_MANAGE; @@ -780,7 +1061,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); @@ -790,58 +1071,148 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ } /** - * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0100 - * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0100 - * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0100 +* @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0100 +* @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0100"; try { + string bundleName; string fileName; int32_t errCode = 0; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); - EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + auto ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + fileName = BConstants::EXT_BACKUP_MANAGE; + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + ret = service->AppIncrementalFileReady(bundleName, fileName, UniqueFd(-1), UniqueFd(-1), errCode); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0100"; +} + +/** +* @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0200 +* @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0200 +* @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0200"; + try { + string fileName; + int32_t errCode = 0; + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); - EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); + ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + + fileName = BConstants::EXT_BACKUP_MANAGE; + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); + ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0200"; +} + +/** +* @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0300 +* @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0300 +* @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0300"; + try { + string fileName; + int32_t errCode = 0; + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); - EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); - EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); - EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + fileName = BConstants::EXT_BACKUP_MANAGE; + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady."; } - GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0100"; + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0300"; } /** - * @tc.number: SUB_ServiceIncremental_AppIncrementalDone_0000 - * @tc.name: SUB_ServiceIncremental_AppIncrementalDone_0000 - * @tc.desc: 测试 AppIncrementalDone 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_AppIncrementalDone_0000 +* @tc.name: SUB_ServiceIncremental_AppIncrementalDone_0000 +* @tc.desc: 测试 AppIncrementalDone 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalDone_0000"; @@ -853,12 +1224,34 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + ret = service->AppIncrementalDone(errCode); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); ret = service->AppIncrementalDone(errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + service->backupExtMutexMap_.clear(); + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); + EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->backupExtMutexMap_.clear(); + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); + EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->AppIncrementalDone(errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -869,14 +1262,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, } /** - * @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0000 - * @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0000 - * @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0000 +* @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0000 +* @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0000"; @@ -885,48 +1278,100 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle string fileName; auto session_ = service->session_; service->session_ = nullptr; - EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); auto ret = service->GetIncrementalFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + ret = service->GetIncrementalFileHandle(bundleName, fileName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN)); + ret = service->GetIncrementalFileHandle(bundleName, fileName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + ret = service->GetIncrementalFileHandle(bundleName, fileName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); ret = service->GetIncrementalFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0000"; +} +/** +* @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0100 +* @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0100 +* @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0100"; + try { + string bundleName; + string fileName; + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)) + .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); + EXPECT_CALL(*srvMock, GetUserIdDefault()).WillOnce(Return(0)); + auto ret = service->GetIncrementalFileHandle(bundleName, fileName); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); ret = service->GetIncrementalFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT)); + EXPECT_CALL(*srvMock, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(true)); ret = service->GetIncrementalFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle."; } - GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0000"; + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0100"; } /** - * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0000 - * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0000 - * @tc.desc: 测试 IncrementalBackup 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_IncrementalBackup_0000 +* @tc.name: SUB_ServiceIncremental_IncrementalBackup_0000 +* @tc.desc: 测试 IncrementalBackup 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0000"; @@ -934,20 +1379,17 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, string bundleName; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - bool res = service->IncrementalBackup(bundleName); - EXPECT_TRUE(res); + EXPECT_TRUE(service->IncrementalBackup(bundleName)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - res = service->IncrementalBackup(bundleName); - EXPECT_TRUE(res); + EXPECT_TRUE(service->IncrementalBackup(bundleName)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - auto ret = service->IncrementalBackup(bundleName); - EXPECT_FALSE(ret); + EXPECT_FALSE(service->IncrementalBackup(bundleName)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); @@ -957,8 +1399,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(0)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); - ret = service->IncrementalBackup(bundleName); - EXPECT_TRUE(ret); + EXPECT_TRUE(service->IncrementalBackup(bundleName)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); @@ -968,15 +1409,13 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); - ret = service->IncrementalBackup(bundleName); - EXPECT_TRUE(ret); + EXPECT_TRUE(service->IncrementalBackup(bundleName)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); - ret = service->IncrementalBackup(bundleName); - EXPECT_FALSE(ret); + EXPECT_FALSE(service->IncrementalBackup(bundleName)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup."; @@ -985,14 +1424,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, } /** - * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0100 - * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0100 - * @tc.desc: 测试 IncrementalBackup 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_IncrementalBackup_0100 +* @tc.name: SUB_ServiceIncremental_IncrementalBackup_0100 +* @tc.desc: 测试 IncrementalBackup 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0100"; @@ -1002,37 +1441,32 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); - auto ret = service->IncrementalBackup(bundleName); - EXPECT_FALSE(ret); + EXPECT_FALSE(service->IncrementalBackup(bundleName)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); - ret = service->IncrementalBackup(bundleName); - EXPECT_FALSE(ret); + EXPECT_FALSE(service->IncrementalBackup(bundleName)); set fileNameVec { "fileName" }; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return("")); EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); - EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)) .WillOnce(Return(make_tuple(BError(BError::Codes::OK).GetCode(), UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); - ret = service->IncrementalBackup(bundleName); - EXPECT_TRUE(ret); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_TRUE(service->IncrementalBackup(bundleName)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup."; @@ -1041,39 +1475,41 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, } /** - * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0200 - * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0200 - * @tc.desc: 测试 IncrementalBackup 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_IncrementalBackup_0200 +* @tc.name: SUB_ServiceIncremental_IncrementalBackup_0200 +* @tc.desc: 测试 IncrementalBackup 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0200"; try { string bundleName; set fileNameVec { "fileName" }; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return("1.0.0")); EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); - EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)) .WillOnce(Return(make_tuple(BError(BError::Codes::SA_INVAL_ARG).GetCode(), UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); - auto ret = service->IncrementalBackup(bundleName); - EXPECT_TRUE(ret); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_TRUE(service->IncrementalBackup(bundleName)); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_FALSE(service->IncrementalBackup(bundleName)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup."; @@ -1082,14 +1518,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, } /** - * @tc.number: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000 - * @tc.name: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000 - * @tc.desc: 测试 NotifyCallerCurAppIncrementDone 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000 +* @tc.name: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000 +* @tc.desc: 测试 NotifyCallerCurAppIncrementDone 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000"; @@ -1119,14 +1555,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_NotifyCallerCurAppIncrem } /** - * @tc.number: SUB_ServiceIncremental_SendUserIdToApp_0000 - * @tc.name: SUB_ServiceIncremental_SendUserIdToApp_0000 - * @tc.desc: 测试 SendUserIdToApp 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_SendUserIdToApp_0000 +* @tc.name: SUB_ServiceIncremental_SendUserIdToApp_0000 +* @tc.desc: 测试 SendUserIdToApp 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SendUserIdToApp_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SendUserIdToApp_0000"; @@ -1154,14 +1590,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SendUserIdToApp_0000, Te } /** - * @tc.number: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000 - * @tc.name: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000 - * @tc.desc: 测试 SetCurrentBackupSessProperties 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000 +* @tc.name: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000 +* @tc.desc: 测试 SetCurrentBackupSessProperties 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000"; @@ -1169,9 +1605,6 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProp vector bundleNames { "bundleName" }; int32_t userId = 100; vector bundleInfos; - BJsonEntityCaps::BundleInfo bundleInfo; - bundleInfo.name = "bundleName"; - bundleInfos.push_back(bundleInfo); auto session_ = service->session_; service->session_ = nullptr; EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false)); @@ -1181,6 +1614,23 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProp EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true)); service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true); EXPECT_TRUE(true); + + EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false)); + service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, false); + EXPECT_TRUE(true); + + BJsonEntityCaps::BundleInfo bundleInfo; + bundleInfo.name = "bundleName"; + bundleInfos.push_back(bundleInfo); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")); + EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false)); + service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, false); + EXPECT_TRUE(true); + + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")); + EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false)); + service->SetCurrentBackupSessProperties(bundleNames, userId, bundleInfos, true); + EXPECT_TRUE(true); service->session_ = session_; } catch (...) { EXPECT_TRUE(false); @@ -1190,14 +1640,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProp } /** - * @tc.number: SUB_ServiceIncremental_Release_0000 - * @tc.name: SUB_ServiceIncremental_Release_0000 - * @tc.desc: 测试 Release 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_Release_0000 +* @tc.name: SUB_ServiceIncremental_Release_0000 +* @tc.desc: 测试 Release 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Release_0000"; @@ -1209,15 +1659,18 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.L service->session_ = session_; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); ret = service->Release(); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); ret = service->Release(); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); ret = service->Release(); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1229,14 +1682,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.L } /** - * @tc.number: SUB_ServiceIncremental_SetBundleIncDataInfo_0000 - * @tc.name: SUB_ServiceIncremental_SetBundleIncDataInfo_0000 - * @tc.desc: 测试 SetBundleIncDataInfo 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_SetBundleIncDataInfo_0000 +* @tc.name: SUB_ServiceIncremental_SetBundleIncDataInfo_0000 +* @tc.desc: 测试 SetBundleIncDataInfo 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetBundleIncDataInfo_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetBundleIncDataInfo_0000"; @@ -1263,14 +1716,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetBundleIncDataInfo_000 } /** - * @tc.number: SUB_ServiceIncremental_Cancel_0000 - * @tc.name: SUB_ServiceIncremental_Cancel_0000 - * @tc.desc: 测试 Cancel 的正常/异常分支 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issueIAKC3I - */ +* @tc.number: SUB_ServiceIncremental_Cancel_0000 +* @tc.name: SUB_ServiceIncremental_Cancel_0000 +* @tc.desc: 测试 Cancel 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000"; @@ -1279,27 +1732,75 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Le BackupExtInfo info {}; info.backupExtName = "com.example.app2backup"; SvcSessionManager::Impl impl; - impl.backupExtNameMap.insert(make_pair(bundleName, info)); int32_t result; + auto session_ = service->session_; + service->session_ = nullptr; + EXPECT_EQ(service->Cancel(bundleName, result), + BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); + service->session_ = session_; + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode())); + auto ret = service->Cancel(bundleName, result); + EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); service->Cancel(bundleName, result); EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); + impl.backupExtNameMap.insert(make_pair(bundleName, info)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN)); service->Cancel(bundleName, result); EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0000"; +} + +/** +* @tc.number: SUB_ServiceIncremental_Cancel_0100 +* @tc.name: SUB_ServiceIncremental_Cancel_0100 +* @tc.desc: 测试 Cancel 的正常/异常分支 +* @tc.size: MEDIUM +* @tc.type: FUNC +* @tc.level Level 1 +* @tc.require: issueIAKC3I +*/ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000"; + try { + string bundleName = "com.example.app2backup"; + BackupExtInfo info {}; + info.backupExtName = "com.example.app2backup"; + SvcSessionManager::Impl impl; + int32_t result; + impl.backupExtNameMap.insert(make_pair(bundleName, info)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START)); service->Cancel(bundleName, result); EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) - .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); @@ -1309,6 +1810,6 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Le EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel."; } - GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0000"; + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0100"; } } \ No newline at end of file -- Gitee