From 773b2544acbebc5b9053912f47104d33ab1f5e8e Mon Sep 17 00:00:00 2001 From: "yaoruozi1@huawei.com" Date: Wed, 25 Dec 2024 21:58:35 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E4=BC=98=E5=8C=96=EF=BC=8C?= =?UTF-8?q?=E5=8E=BB=E9=99=A4throw=20part2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yaoruozi1@huawei.com --- .../native/backup_ext/src/ext_backup.cpp | 8 + .../backup_sa/include/module_ipc/service.h | 3 + .../include/module_ipc/svc_session_manager.h | 2 +- services/backup_sa/src/module_ipc/service.cpp | 70 +- .../src/module_ipc/service_incremental.cpp | 31 +- .../backup_sa/src/module_ipc/sub_service.cpp | 69 ++ .../src/module_ipc/svc_session_manager.cpp | 327 +++++-- tests/mock/module_ipc/service_mock.cpp | 2 + .../module_ipc/svc_session_manager_mock.cpp | 8 +- .../svc_session_manager_throw_mock.cpp | 3 +- .../svc_session_manager_throw_mock.h | 6 +- .../module_ipc/service_incremental_test.cpp | 29 +- .../backup_sa/module_ipc/sub_service_test.cpp | 4 + .../module_ipc/svc_session_manager_test.cpp | 893 +++++++----------- utils/include/b_resources/b_constants.h | 1 + 15 files changed, 740 insertions(+), 716 deletions(-) diff --git a/frameworks/native/backup_ext/src/ext_backup.cpp b/frameworks/native/backup_ext/src/ext_backup.cpp index 92e37c8b7..e75dcf5f8 100644 --- a/frameworks/native/backup_ext/src/ext_backup.cpp +++ b/frameworks/native/backup_ext/src/ext_backup.cpp @@ -238,6 +238,10 @@ void ExtBackup::OnDisconnect(const AAFwk::Want &want) bool ExtBackup::WasFromSpecialVersion(void) { + if (appVersionStr_.empty()) { + HILOGE("App version name is empty"); + return false; + } std::string appVersionFlag_ = appVersionStr_.substr(0, appVersionStr_.find_first_of(BConstants::VERSION_NAME_SEPARATOR_CHAR)); if (appVersionFlag_ == BConstants::DEFAULT_VERSION_NAME) { @@ -248,6 +252,10 @@ bool ExtBackup::WasFromSpecialVersion(void) bool ExtBackup::SpecialVersionForCloneAndCloud(void) { + if (appVersionStr_.empty()) { + HILOGE("App version name is empty"); + return false; + } std::string appVersionFlag_ = appVersionStr_.substr(0, appVersionStr_.find_first_of(BConstants::VERSION_NAME_SEPARATOR_CHAR)); auto iter = diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h index d877ad4a6..95f2a9514 100644 --- a/services/backup_sa/include/module_ipc/service.h +++ b/services/backup_sa/include/module_ipc/service.h @@ -570,6 +570,9 @@ private: std::vector &supportBundleNames); void CancelTask(std::string bundleName, wptr ptr); + bool HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup); + bool HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup); + void StartCurBundleBackupOrRestore(const std::string &bundleName); private: static sptr instance_; static std::mutex instanceLock_; diff --git a/services/backup_sa/include/module_ipc/svc_session_manager.h b/services/backup_sa/include/module_ipc/svc_session_manager.h index 1d63fdf2b..8be1c65e0 100644 --- a/services/backup_sa/include/module_ipc/svc_session_manager.h +++ b/services/backup_sa/include/module_ipc/svc_session_manager.h @@ -560,7 +560,7 @@ private: * @param bundleName 应用名称 * @return std::map::iterator */ - std::map::iterator GetBackupExtNameMap(const std::string &bundleName); + std::tuple::iterator> GetBackupExtNameMap(const std::string &bundleName); /** * @brief 计算出应用程序处理数据可能使用的时间 diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp index 5cc8e65cd..89e9009ea 100644 --- a/services/backup_sa/src/module_ipc/service.cpp +++ b/services/backup_sa/src/module_ipc/service.cpp @@ -1105,28 +1105,51 @@ void Service::ExtStart(const string &bundleName) if (IncrementalBackup(bundleName)) { return; } - IServiceReverse::Scenario scenario = session_->GetScenario(); - auto backUpConnection = session_->GetExtConnection(bundleName); - if (backUpConnection == nullptr) { - throw BError(BError::Codes::SA_INVAL_ARG, "ExtStart bundle task error, backUpConnection is empty"); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - throw BError(BError::Codes::SA_INVAL_ARG, "ExtStart bundle task error, Extension backup Proxy is empty"); + StartCurBundleBackupOrRestore(bundleName); + } catch (...) { + HILOGI("Unexpected exception, bundleName: %{public}s", bundleName.c_str()); + ClearSessionAndSchedInfo(bundleName); + NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); + } +} + +void Service::StartCurBundleBackupOrRestore(const std::string &bundleName) +{ + HILOGI("Begin handle current bundle full backup or full restore, bundleName:%{public}s", bundleName.c_str()); + IServiceReverse::Scenario scenario = session_->GetScenario(); + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("Error, backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); + if (scenario == IServiceReverse::Scenario::BACKUP) { + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); + } else if (scenario == IServiceReverse::Scenario::RESTORE) { + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); } + return; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (proxy == nullptr) { + HILOGE("Error, Extension backup Proxy is empty, bundle:%{public}s", bundleName.c_str()); if (scenario == IServiceReverse::Scenario::BACKUP) { - auto ret = proxy->HandleBackup(session_->GetClearDataFlag(bundleName)); - session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); - BundleBeginRadarReport(bundleName, ret, scenario); - if (ret) { - ClearSessionAndSchedInfo(bundleName); - NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); - } - return; + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); + } else if (scenario == IServiceReverse::Scenario::RESTORE) { + session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), + bundleName); } - if (scenario != IServiceReverse::Scenario::RESTORE) { - throw BError(BError::Codes::SA_INVAL_ARG, "Failed to scenario"); + return; + } + if (scenario == IServiceReverse::Scenario::BACKUP) { + auto ret = proxy->HandleBackup(session_->GetClearDataFlag(bundleName)); + session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); + BundleBeginRadarReport(bundleName, ret, scenario); + if (ret) { + ClearSessionAndSchedInfo(bundleName); + NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); } + } else if (scenario == IServiceReverse::Scenario::RESTORE) { auto ret = proxy->HandleRestore(session_->GetClearDataFlag(bundleName)); session_->GetServiceReverseProxy()->RestoreOnBundleStarted(ret, bundleName); GetOldDeviceBackupVersion(); @@ -1138,11 +1161,8 @@ void Service::ExtStart(const string &bundleName) session_->GetServiceReverseProxy()->RestoreOnFileReady(bundleName, fileName, move(fd), errCode); FileReadyRadarReport(bundleName, fileName, errCode, scenario); } - } catch (...) { - HILOGI("Unexpected exception, bundleName: %{public}s", bundleName.c_str()); - ClearSessionAndSchedInfo(bundleName); - NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); } + HILOGI("End handle current bundle full backup or full restore, bundleName:%{public}s", bundleName.c_str()); } int Service::Dump(int fd, const vector &args) @@ -1260,6 +1280,12 @@ void Service::ExtConnectDone(string bundleName) HILOGE("begin %{public}s", bundleName.data()); BConstants::ServiceSchedAction curSchedAction = session_->GetServiceSchedAction(bundleName); + if (curSchedAction == BConstants::ServiceSchedAction::UNKNOWN) { + HILOGE("Can not find bundle from this session, bundleName:%{public}s", bundleName.c_str()); + ClearSessionAndSchedInfo(bundleName); + NoticeClientFinish(bundleName, BError(BError::Codes::SA_REFUSED_ACT)); + return; + } if (curSchedAction == BConstants::ServiceSchedAction::CLEAN) { sched_->Sched(bundleName); return; diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp index d3a9a67ae..6f53f917d 100644 --- a/services/backup_sa/src/module_ipc/service_incremental.cpp +++ b/services/backup_sa/src/module_ipc/service_incremental.cpp @@ -600,32 +600,15 @@ ErrCode Service::AppIncrementalDone(ErrCode errCode) HILOGE("AppIncrementalDone error, session is null"); return BError(BError::Codes::SA_INVAL_ARG); } - string callerName = VerifyCallerAndGetCallerName(); + string callerName = ""; + ErrCode ret = VerifyCallerAndGetCallerName(callerName); + if (ret != ERR_OK) { + HILOGE("App incremental done fail, ret:%{public}d", ret); + return ret; + } HILOGI("Service AppIncrementalDone start, callerName is %{public}s, errCode is: %{public}d", callerName.c_str(), errCode); - if (session_->OnBundleFileReady(callerName) || errCode != BError(BError::Codes::OK)) { - std::shared_ptr mutexPtr = GetExtensionMutex(callerName); - if (mutexPtr == nullptr) { - HILOGE("extension mutex ptr is nullptr"); - return BError(BError::Codes::SA_INVAL_ARG, "Extension mutex ptr is null."); - } - std::lock_guard lock(mutexPtr->callbackMutex); - auto tempBackUpConnection = session_->GetExtConnection(callerName); - auto backUpConnection = tempBackUpConnection.promote(); - if (backUpConnection == nullptr) { - return BError(BError::Codes::SA_INVAL_ARG, "Promote backUpConnection ptr is null."); - } - auto proxy = backUpConnection->GetBackupExtProxy(); - if (!proxy) { - return BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty"); - } - proxy->HandleClear(); - session_->StopFwkTimer(callerName); - session_->StopExtTimer(callerName); - backUpConnection->DisconnectBackupExtAbility(); - ClearSessionAndSchedInfo(callerName); - NotifyCallerCurAppIncrementDone(errCode, callerName); - } + HandleCurAppDone(errCode, callerName, true); RemoveExtensionMutex(callerName); OnAllBundlesFinished(BError(BError::Codes::OK)); return BError(BError::Codes::OK); diff --git a/services/backup_sa/src/module_ipc/sub_service.cpp b/services/backup_sa/src/module_ipc/sub_service.cpp index c6dc5dd4e..cd9e8772d 100644 --- a/services/backup_sa/src/module_ipc/sub_service.cpp +++ b/services/backup_sa/src/module_ipc/sub_service.cpp @@ -431,4 +431,73 @@ void Service::GetOldDeviceBackupVersion() } HILOGI("backupVersion of old device = %{public}s", oldBackupVersion.c_str()); } + +bool Service::HandleCurBundleFileReady(const std::string &bundleName, const std::string &fileName, bool isIncBackup) +{ + if (session_->OnBundleFileReady(bundleName, fileName)) { + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("AppFileReady error, backUpConnection is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("AppFileReady error, Extension backup Proxy is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + // 通知extension清空缓存 + proxy->HandleClear(); + // 清除Timer + session_->StopFwkTimer(bundleName); + session_->StopExtTimer(bundleName); + // 通知TOOL 备份完成 + if (isIncBackup) { + session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), + bundleName); + } else { + session_->GetServiceReverseProxy()->BackupOnBundleFinished(BError(BError::Codes::OK), bundleName); + } + BundleEndRadarReport(bundleName, BError(BError::Codes::OK), session_->GetScenario()); + // 断开extension + backUpConnection->DisconnectBackupExtAbility(); + ClearSessionAndSchedInfo(bundleName); + return true; + } + return false; +} + +bool Service::HandleCurAppDone(ErrCode errCode, const std::string &bundleName, bool isIncBackup) +{ + bool fileReadySucc = session_->OnBundleFileReady(bundleName); + if (fileReadySucc || errCode != BError(BError::Codes::OK)) { + std::shared_ptr mutexPtr = GetExtensionMutex(bundleName); + if (mutexPtr == nullptr) { + HILOGE("extension mutex ptr is nullptr, bundleName:%{public}s", bundleName.c_str()); + return false; + } + std::lock_guard lock(mutexPtr->callbackMutex); + auto backUpConnection = session_->GetExtConnection(bundleName); + if (backUpConnection == nullptr) { + HILOGE("App finish error, backUpConnection is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("App finish error, Extension backup Proxy is empty, bundleName:%{public}s", bundleName.c_str()); + return false; + } + proxy->HandleClear(); + session_->StopFwkTimer(bundleName); + session_->StopExtTimer(bundleName); + backUpConnection->DisconnectBackupExtAbility(); + ClearSessionAndSchedInfo(bundleName); + if (isIncBackup) { + NotifyCallerCurAppIncrementDone(errCode, bundleName); + } else { + NotifyCallerCurAppDone(errCode, bundleName); + } + return true; + } + return false; +} } \ No newline at end of file diff --git a/services/backup_sa/src/module_ipc/svc_session_manager.cpp b/services/backup_sa/src/module_ipc/svc_session_manager.cpp index 9fec17ab3..3d9566242 100644 --- a/services/backup_sa/src/module_ipc/svc_session_manager.cpp +++ b/services/backup_sa/src/module_ipc/svc_session_manager.cpp @@ -170,16 +170,15 @@ bool SvcSessionManager::OnBundleFileReady(const string &bundleName, const string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("OnBundleFileReady failed, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), + GetAnonyPath(fileName).c_str()); + return false; } - HILOGD("Begin, bundleName name is:%{public}s", bundleName.c_str()); - auto it = impl_.backupExtNameMap.find(bundleName); - if (it == impl_.backupExtNameMap.end()) { - stringstream ss; - ss << "Could not find the " << bundleName << " from current session"; - throw BError(BError::Codes::SA_REFUSED_ACT, ss.str()); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find the bundle:%{public}s", bundleName.c_str()); + return false; } - // 判断是否结束 通知EXTENTION清理资源 TOOL应用完成备份 if (impl_.scenario == IServiceReverse::Scenario::RESTORE || SAUtils::IsSABundleName(bundleName)) { it->second.isBundleFinished = true; @@ -206,10 +205,12 @@ bool SvcSessionManager::OnBundleFileReady(const string &bundleName, const string UniqueFd SvcSessionManager::OnBundleExtManageInfo(const string &bundleName, UniqueFd fd) { if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return UniqueFd(-EPERM); } if (impl_.scenario != IServiceReverse::Scenario::BACKUP) { - throw BError(BError::Codes::SA_INVAL_ARG, "Invalid Scenario"); + HILOGE("Invalid Scenario, bundleName:%{public}s", bundleName.c_str()); + return UniqueFd(-EPERM); } BJsonCachedEntity cachedEntity(move(fd)); @@ -217,12 +218,16 @@ UniqueFd SvcSessionManager::OnBundleExtManageInfo(const string &bundleName, Uniq auto info = cache.GetExtManage(); for (auto &fileName : info) { - HILOGE("fileName %{public}s", GetAnonyString(fileName).data()); + HILOGE("fileName %{public}s", GetAnonyPath(fileName).data()); OnBundleFileReady(bundleName, fileName); } unique_lock lock(lock_); - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find the bundle:%{public}s", bundleName.c_str()); + return UniqueFd(-EPERM); + } it->second.receExtManageJson = true; return move(cachedEntity.GetFd()); } @@ -233,7 +238,7 @@ void SvcSessionManager::RemoveExtInfo(const string &bundleName) unique_lock lock(lock_); auto it = impl_.backupExtNameMap.find(bundleName); if (it == impl_.backupExtNameMap.end()) { - HILOGI("BackupExtNameMap not contain %{public}s", bundleName.c_str()); + HILOGE("BackupExtNameMap not contain %{public}s", bundleName.c_str()); return; } if (extConnectNum_) { @@ -252,12 +257,18 @@ wptr SvcSessionManager::GetExtConnection(const BundleName & HILOGD("svcMrg:GetExt, bundleName:%{public}s", bundleName.c_str()); shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return nullptr; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find current bundle, bundleName:%{public}s", bundleName.c_str()); + return nullptr; + } if (!it->second.backUpConnection) { - throw BError(BError::Codes::SA_INVAL_ARG, "Svc backup connection is empty"); + HILOGE("Svc backup connection is empty, bundleName:%{public}s", bundleName.c_str()); + return nullptr; } return wptr(it->second.backUpConnection); @@ -268,12 +279,18 @@ std::weak_ptr SvcSessionManager::GetSAExtConnection(const Bu HILOGD("svcMrg:GetExt, bundleName:%{public}s", bundleName.c_str()); shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return std::weak_ptr(); } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find current bundle, bundleName:%{public}s", bundleName.c_str()); + return std::weak_ptr(); + } if (!it->second.saBackupConnection) { - throw BError(BError::Codes::SA_INVAL_ARG, "SA backup connection is empty"); + HILOGE("SA backup connection is empty, bundleName:%{public}s", bundleName.c_str()); + return std::weak_ptr(); } return std::weak_ptr(it->second.saBackupConnection); @@ -395,10 +412,14 @@ void SvcSessionManager::SetExtFileNameRequest(const string &bundleName, const st { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find current bundle, bundleName:%{public}s", bundleName.c_str()); + return; } - - auto it = GetBackupExtNameMap(bundleName); it->second.fileNameInfo.insert(fileName); } @@ -406,27 +427,33 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return std::set(); } if (impl_.scenario != IServiceReverse::Scenario::RESTORE) { - throw BError(BError::Codes::SA_INVAL_ARG, "Invalid Scenario"); + HILOGE("Invalid Scenario, bundleName:%{public}s", bundleName.c_str()); + return std::set(); + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return std::set(); } - auto it = GetBackupExtNameMap(bundleName); set fileNameInfo = it->second.fileNameInfo; it->second.fileNameInfo.clear(); return fileNameInfo; } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &bundleName) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap( + const string &bundleName) { auto it = impl_.backupExtNameMap.find(bundleName); if (it == impl_.backupExtNameMap.end()) { - stringstream ss; - ss << "Could not find the " << bundleName << " from current session"; - throw BError(BError::Codes::SA_REFUSED_ACT, ss.str()); + HILOGE("Could not find the bundle from current session, bundleName:%{public}s", bundleName.c_str()); + return {false, impl_.backupExtNameMap.end()}; } - return it; + return {true, it}; } bool SvcSessionManager::GetSchedBundleName(string &bundleName) @@ -456,9 +483,14 @@ BConstants::ServiceSchedAction SvcSessionManager::GetServiceSchedAction(const st { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return BConstants::ServiceSchedAction::UNKNOWN; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return BConstants::ServiceSchedAction::UNKNOWN; } - auto it = GetBackupExtNameMap(bundleName); return it->second.schedAction; } @@ -466,10 +498,14 @@ void SvcSessionManager::SetServiceSchedAction(const string &bundleName, BConstan { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - - auto it = GetBackupExtNameMap(bundleName); it->second.schedAction = action; if (it->second.schedAction == BConstants::ServiceSchedAction::START) { extConnectNum_++; @@ -480,10 +516,15 @@ void SvcSessionManager::SetBackupExtName(const string &bundleName, const string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.backupExtName = backupExtName; } @@ -491,10 +532,15 @@ string SvcSessionManager::GetBackupExtName(const string &bundleName) { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return ""; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return ""; + } return it->second.backupExtName; } @@ -502,10 +548,15 @@ void SvcSessionManager::SetBackupExtInfo(const string &bundleName, const string { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.extInfo = extInfo; } @@ -513,10 +564,15 @@ std::string SvcSessionManager::GetBackupExtInfo(const string &bundleName) { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return ""; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return ""; + } return it->second.extInfo; } @@ -524,7 +580,8 @@ void SvcSessionManager::AppendBundles(const vector &bundleNames) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("AppendBundles error, No caller token was specified"); + return; } for (auto &&bundleName : bundleNames) { @@ -578,7 +635,8 @@ bool SvcSessionManager::IsOnAllBundlesFinished() { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("IsOnAllBundlesFinished error, No caller token was specified"); + return false; } bool isAllBundlesFinished = !impl_.backupExtNameMap.size(); if (impl_.scenario == IServiceReverse::Scenario::RESTORE) { @@ -594,7 +652,8 @@ bool SvcSessionManager::IsOnOnStartSched() HILOGI("Begin"); shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("IsOnOnStartSched error, No caller token was specified"); + return false; } if (impl_.isBackupStart && impl_.backupExtNameMap.size()) { return true; @@ -622,10 +681,15 @@ void SvcSessionManager::SetBundleRestoreType(const std::string &bundleName, Rest { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.restoreType = restoreType; } @@ -633,10 +697,15 @@ RestoreTypeEnum SvcSessionManager::GetBundleRestoreType(const std::string &bundl { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; + } return it->second.restoreType; } @@ -644,10 +713,15 @@ void SvcSessionManager::SetBundleVersionCode(const std::string &bundleName, int6 { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.versionCode = versionCode; } @@ -655,10 +729,15 @@ int64_t SvcSessionManager::GetBundleVersionCode(const std::string &bundleName) { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return 0; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return 0; + } return it->second.versionCode; } @@ -666,10 +745,15 @@ void SvcSessionManager::SetBundleVersionName(const std::string &bundleName, std: { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.versionName = versionName; } @@ -677,10 +761,15 @@ std::string SvcSessionManager::GetBundleVersionName(const std::string &bundleNam { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return ""; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return ""; + } return it->second.versionName; } @@ -688,10 +777,15 @@ void SvcSessionManager::SetBundleDataSize(const std::string &bundleName, int64_t { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; + } it->second.dataSize = dataSize; } @@ -705,14 +799,14 @@ uint32_t SvcSessionManager::CalAppProcessTime(const std::string &bundleName) int64_t timeout; uint32_t resTimeoutMs; - try { - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("CalAppProcessTime failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + timeout = defaultTimeout; + } else { int64_t appSize = it->second.dataSize; /* timeout = (AppSize / 3Ms) * 3 + 30 */ timeout = defaultTimeout + (appSize / processRate) * multiple; - } catch (const BError &e) { - HILOGE("Failed to get app<%{public}s> dataInfo, err=%{public}d", bundleName.c_str(), e.GetCode()); - timeout = defaultTimeout; } timeout = timeout < minTimeout ? minTimeout : timeout; resTimeoutMs = (uint32_t)(timeout * invertMillisecond % UINT_MAX); /* conver second to millisecond */ @@ -729,7 +823,11 @@ bool SvcSessionManager::StartFwkTimer(const std::string &bundleName, const Utils HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Start fwk timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.fwkTimerStatus == true) { HILOGE("FwkTimer is registered, unregister first."); return false; @@ -750,7 +848,11 @@ bool SvcSessionManager::StopFwkTimer(const std::string &bundleName) HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Stop fwk timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.fwkTimerStatus == false) { HILOGE("FwkTimer is unregistered, register first."); return true; @@ -770,7 +872,11 @@ bool SvcSessionManager::StartExtTimer(const std::string &bundleName, const Utils HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Start extension timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.extTimerStatus == true) { HILOGE("ExtTimer is registered, unregister first."); return false; @@ -791,7 +897,11 @@ bool SvcSessionManager::StopExtTimer(const std::string &bundleName) HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Stop extension timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } if (it->second.extTimerStatus == false) { HILOGE("ExtTimer is unregistered, register first."); return true; @@ -813,7 +923,11 @@ bool SvcSessionManager::UpdateTimer(const std::string &bundleName, uint32_t time HILOGE("No caller token was specified"); return false; } - auto it = GetBackupExtNameMap(bundleName); + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("Update timer failed, BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return false; + } it->second.timeout = timeout; if (it->second.extTimerStatus == false) { HILOGI("ExtTimer is unregistered, just store timeout %{public}u(ms)", timeout); @@ -886,7 +1000,8 @@ bool SvcSessionManager::GetIsIncrementalBackup() { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("GetIsIncrementalBackup error, No caller token was specified"); + return false; } return impl_.isIncrementalBackup; } @@ -895,9 +1010,14 @@ void SvcSessionManager::SetIncrementalData(const BIncrementalData &incrementalDa { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("SetIncrementalData error, No caller token was specified"); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(incrementalData.bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", incrementalData.bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(incrementalData.bundleName); it->second.lastIncrementalTime = incrementalData.lastIncrementalTime; it->second.manifestFd = incrementalData.manifestFd; it->second.backupParameters = incrementalData.backupParameters; @@ -908,9 +1028,14 @@ int32_t SvcSessionManager::GetIncrementalManifestFd(const string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return BConstants::INVALID_FD_NUM; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return BConstants::INVALID_FD_NUM; } - auto it = GetBackupExtNameMap(bundleName); return it->second.manifestFd; } @@ -918,9 +1043,14 @@ int64_t SvcSessionManager::GetLastIncrementalTime(const string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return 0; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return 0; } - auto it = GetBackupExtNameMap(bundleName); return it->second.lastIncrementalTime; } @@ -938,19 +1068,30 @@ void SvcSessionManager::SetClearDataFlag(const std::string &bundleName, bool isC { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); it->second.isClearData = isClearData; HILOGI("bundleName:%{public}s, set clear data flag:%{public}d.", bundleName.c_str(), isClearData); } + bool SvcSessionManager::GetClearDataFlag(const std::string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return true; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return true; } - auto it = GetBackupExtNameMap(bundleName); return it->second.isClearData; } @@ -1014,9 +1155,14 @@ void SvcSessionManager::SetPublishFlag(const std::string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); it->second.isInPublishFile = true; HILOGE("Set PublishFile success, bundleName = %{public}s", bundleName.c_str()); } @@ -1025,7 +1171,8 @@ void SvcSessionManager::SetOldBackupVersion(const std::string &backupVersion) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("Error, No caller token was specified"); + return; } impl_.oldBackupVersion = backupVersion; } @@ -1034,7 +1181,8 @@ std::string SvcSessionManager::GetOldBackupVersion() { shared_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("Error, No caller token was specified"); + return ""; } return impl_.oldBackupVersion; } @@ -1048,9 +1196,14 @@ void SvcSessionManager::SetIsReadyLaunch(const std::string &bundleName) { unique_lock lock(lock_); if (!impl_.clientToken) { - throw BError(BError::Codes::SA_INVAL_ARG, "No caller token was specified"); + HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto [findBundleSuc, it] = GetBackupExtNameMap(bundleName); + if (!findBundleSuc) { + HILOGE("BackupExtNameMap can not find bundle %{public}s", bundleName.c_str()); + return; } - auto it = GetBackupExtNameMap(bundleName); it->second.isReadyLaunch = true; HILOGE("SetIsReadyLaunch success, bundleName = %{public}s", bundleName.c_str()); } diff --git a/tests/mock/module_ipc/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp index 786a66bcc..779d1aaec 100644 --- a/tests/mock/module_ipc/service_mock.cpp +++ b/tests/mock/module_ipc/service_mock.cpp @@ -320,4 +320,6 @@ void Service::HandleNotSupportBundleNames(const vector&, vector& void Service::SetBundleIncDataInfo(const std::vector&, std::vector&) {} void Service::CancelTask(std::string bundleName, wptr ptr) {} + +void SetUserIdAndRestoreType(RestoreTypeEnum restoreType, int32_t userId) {} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/module_ipc/svc_session_manager_mock.cpp b/tests/mock/module_ipc/svc_session_manager_mock.cpp index 1e9e265b8..8d06c14c5 100644 --- a/tests/mock/module_ipc/svc_session_manager_mock.cpp +++ b/tests/mock/module_ipc/svc_session_manager_mock.cpp @@ -142,11 +142,15 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string return fileNameInfo; } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &bundleName) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap( + const string &bundleName) { GTEST_LOG_(INFO) << "GetBackupExtNameMap"; auto it = impl_.backupExtNameMap.find(bundleName); - return it; + if (it == impl_.backupExtNameMap.end()) { + return {false, impl_.backupExtNameMap.end()}; + } + return {true, it}; } bool SvcSessionManager::GetSchedBundleName(string &bundleName) diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp index c76234055..45d0e439e 100644 --- a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp +++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp @@ -94,7 +94,8 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string return BackupSvcSessionManager::session->GetExtFileNameRequest(bundleName); } -map::iterator SvcSessionManager::GetBackupExtNameMap(const string &bundleName) +std::tuple::iterator> SvcSessionManager::GetBackupExtNameMap( + const string &bundleName) { return BackupSvcSessionManager::session->GetBackupExtNameMap(bundleName); } diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.h b/tests/mock/module_ipc/svc_session_manager_throw_mock.h index 60113e1d7..fb196a517 100644 --- a/tests/mock/module_ipc/svc_session_manager_throw_mock.h +++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.h @@ -42,7 +42,8 @@ public: virtual void InitClient(SvcSessionManager::Impl &) = 0; virtual void SetExtFileNameRequest(const std::string &, const std::string &) = 0; virtual std::set GetExtFileNameRequest(const std::string &) = 0; - virtual std::map::iterator GetBackupExtNameMap(const std::string &) = 0; + virtual std::tuple::iterator> GetBackupExtNameMap( + const std::string &) = 0; virtual bool GetSchedBundleName(std::string &) = 0; virtual BConstants::ServiceSchedAction GetServiceSchedAction(const std::string &) = 0; virtual void SetServiceSchedAction(const std::string &, BConstants::ServiceSchedAction) = 0; @@ -113,7 +114,8 @@ public: MOCK_METHOD(void, InitClient, (SvcSessionManager::Impl &)); MOCK_METHOD(void, SetExtFileNameRequest, (const std::string &, const std::string &)); MOCK_METHOD(std::set, GetExtFileNameRequest, (const std::string &)); - MOCK_METHOD((std::map::iterator), GetBackupExtNameMap, (const std::string &)); + MOCK_METHOD((std::tuple::iterator>), GetBackupExtNameMap, + (const std::string &)); MOCK_METHOD(bool, GetSchedBundleName, (std::string &)); MOCK_METHOD(BConstants::ServiceSchedAction, GetServiceSchedAction, (const std::string &)); MOCK_METHOD(void, SetServiceSchedAction, (const std::string &, BConstants::ServiceSchedAction)); 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 b19ccd042..d38a6933f 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -269,6 +269,18 @@ std::vector Service::GetSupportBackupBundleNames(vectorAppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, 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(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()).WillOnce(Return()); + 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)); @@ -803,16 +815,9 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - ret = service->AppIncrementalDone(errCode); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); - - errCode = BError(BError::Codes::SA_INVAL_ARG).GetCode(); - EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)) - .WillOnce(Return(false)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); ret = service->AppIncrementalDone(errCode); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalDone."; diff --git a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp index ce2c88e40..c995e219c 100644 --- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp @@ -31,6 +31,10 @@ HWTEST_F(ServiceTest, SUB_Service_HandleCurGroupBackupInfos_0000, TestSize.Level map> bundleNameDetailMap; map isClearDataFlags; EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)); service->HandleCurGroupBackupInfos(backupInfos, bundleNameDetailMap, isClearDataFlags); EXPECT_TRUE(true); diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp index 9370532d0..ed1631a99 100644 --- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp @@ -345,49 +345,36 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_getscenario_0100, testing: HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT); - } - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_TRUE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap["123"] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - ret = sessionManagerPtr_->OnBundleFileReady("123"); - EXPECT_TRUE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_FALSE(ret); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by onBundlefileready."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_TRUE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap["123"] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + fileReady = sessionManagerPtr_->OnBundleFileReady("123"); + EXPECT_TRUE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_FALSE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0100"; } @@ -403,40 +390,35 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, te HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0101"; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); - EXPECT_FALSE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "test"); - EXPECT_FALSE(ret); - - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, string(BConstants::EXT_BACKUP_MANAGE)); - EXPECT_FALSE(ret); - - BackupExtInfo info; - info.receExtManageJson = true; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); - EXPECT_TRUE(ret); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by onBundlefileready."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "test"); + EXPECT_FALSE(fileReady); + + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, string(BConstants::EXT_BACKUP_MANAGE)); + EXPECT_FALSE(fileReady); + + BackupExtInfo info; + info.receExtManageJson = true; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); + EXPECT_TRUE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0101"; } @@ -452,42 +434,29 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, te HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleExtManageInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_OnBundleExtManageInfo_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - TestManager tm("SvcSessionManagerTest_GetFd_0100"); - string filePath = tm.GetRootDirCurTest().append(MANAGE_JSON); - SaveStringToFile(filePath, R"({"fileName" : "1.tar"})"); - UniqueFd fd(open(filePath.data(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)); - sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, move(fd)); - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_TRUE(ret); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by OnBundleExtManageInfo."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); + EXPECT_TRUE(move(ret) == -1); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); + EXPECT_TRUE(move(ret) == -1); + + TestManager tm("SvcSessionManagerTest_GetFd_0100"); + string filePath = tm.GetRootDirCurTest().append(MANAGE_JSON); + SaveStringToFile(filePath, R"({"fileName" : "1.tar"})"); + UniqueFd fd(open(filePath.data(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)); + sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, move(fd)); + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); + EXPECT_TRUE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_TRUE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); + EXPECT_TRUE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_TRUE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_OnBundleExtManageInfo_0100"; } @@ -605,14 +574,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0100 { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -639,19 +604,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0100 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0101"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); + EXPECT_TRUE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0101"; } @@ -667,20 +623,11 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0101 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0102, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0102"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); + EXPECT_TRUE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0102"; } @@ -696,20 +643,11 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0102 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0103, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0103"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); + EXPECT_FALSE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0103"; } @@ -725,45 +663,31 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0103 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtConnection_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtConnection_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - BackupExtInfo info; - info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME)); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; - auto ret = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); - EXPECT_EQ(reinterpret_cast(ret.GetRefPtr()), - reinterpret_cast(info.backUpConnection.GetRefPtr())); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtConnection."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto temConnectPtr = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + auto backupExtConnPtr = temConnectPtr.promote(); + EXPECT_TRUE(backupExtConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + temConnectPtr = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + backupExtConnPtr = temConnectPtr.promote(); + EXPECT_TRUE(backupExtConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + temConnectPtr = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + backupExtConnPtr = temConnectPtr.promote(); + EXPECT_TRUE(backupExtConnPtr == nullptr); + + BackupExtInfo info; + info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME)); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; + auto ret = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME); + EXPECT_EQ(reinterpret_cast(ret.GetRefPtr()), + reinterpret_cast(info.backUpConnection.GetRefPtr())); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtConnection_0100"; } @@ -779,44 +703,30 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtConnection_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSAExtConnection_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetSAExtConnection_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT); - } - - try { - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - BackupExtInfo info; - info.saBackupConnection = make_shared(nullptr, nullptr, nullptr, nullptr); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; - auto ret = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME).lock(); - EXPECT_EQ(reinterpret_cast(ret.get()), reinterpret_cast(info.saBackupConnection.get())); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetSAExtConnection."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); + auto backupConnPtr = tempConnPtr.lock(); + EXPECT_TRUE(backupConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); + backupConnPtr = tempConnPtr.lock(); + EXPECT_TRUE(backupConnPtr == nullptr); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME); + backupConnPtr = tempConnPtr.lock(); + EXPECT_TRUE(backupConnPtr == nullptr); + + BackupExtInfo info; + info.saBackupConnection = make_shared(nullptr, nullptr, nullptr, nullptr); + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info; + auto ret = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME).lock(); + EXPECT_EQ(reinterpret_cast(ret.get()), reinterpret_cast(info.saBackupConnection.get())); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetSAExtConnection_0100"; } @@ -955,37 +865,24 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0102 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0103, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0103"; - try { - string bundleName = ""; - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - auto action = sessionManagerPtr_->GetServiceSchedAction(bundleName); - EXPECT_EQ(action, BConstants::ServiceSchedAction::WAIT); - - sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); - action = sessionManagerPtr_->GetServiceSchedAction(bundleName); - EXPECT_NE(action, BConstants::ServiceSchedAction::START); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-SetServiceSchedAction Branches"; - sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::FINISH); - - try { - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetServiceSchedAction(bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - try { - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction."; - } + string bundleName = ""; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + auto action = sessionManagerPtr_->GetServiceSchedAction(bundleName); + EXPECT_EQ(action, BConstants::ServiceSchedAction::UNKNOWN); + + sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); + action = sessionManagerPtr_->GetServiceSchedAction(bundleName); + EXPECT_NE(action, BConstants::ServiceSchedAction::START); + GTEST_LOG_(INFO) << "SvcSessionManagerTest-SetServiceSchedAction Branches"; + sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::FINISH); + + sessionManagerPtr_->impl_.clientToken = 0; + action = sessionManagerPtr_->GetServiceSchedAction(bundleName); + EXPECT_TRUE(action == BConstants::ServiceSchedAction::UNKNOWN); + + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START); + EXPECT_TRUE(true); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0103"; } @@ -1005,7 +902,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0100, tes EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->SetBackupExtName(BUNDLE_NAME, BUNDLE_NAME); string extName = sessionManagerPtr_->GetBackupExtName(BUNDLE_NAME); - EXPECT_EQ(extName, BUNDLE_NAME); + EXPECT_EQ(extName, ""); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtName."; @@ -1025,32 +922,19 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtName_0101"; - try { - string bundleName = ""; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + string bundleName = ""; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); + EXPECT_TRUE(true); - try { - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBackupExtName(bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + sessionManagerPtr_->impl_.clientToken = 0; + auto backupExtName = sessionManagerPtr_->GetBackupExtName(bundleName); + EXPECT_EQ(backupExtName, ""); - sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); - string extName = sessionManagerPtr_->GetBackupExtName(bundleName); - EXPECT_NE(extName, bundleName); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtName."; - } + sessionManagerPtr_->SetBackupExtName(bundleName, bundleName); + string extName = sessionManagerPtr_->GetBackupExtName(bundleName); + EXPECT_EQ(extName, ""); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtName_0101"; } @@ -1066,27 +950,18 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0101, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBackupExtInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBackupExtInfo_0100"; - try { - string bundleName = BUNDLE_NAME; - string extInfo = "test"; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = {}; - sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); - EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBackupExtInfo."; - } + string bundleName = BUNDLE_NAME; + string extInfo = "test"; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); + EXPECT_TRUE(true); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = {}; + sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo); + EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBackupExtInfo_0100"; } @@ -1102,29 +977,20 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBackupExtInfo_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtInfo_0100"; - try { - string bundleName = BUNDLE_NAME; - string extInfo = "test"; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBackupExtInfo(bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - BackupExtInfo info; - info.extInfo = "test"; - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = info; - auto ret = sessionManagerPtr_->GetBackupExtInfo(bundleName); - EXPECT_EQ(ret, "test"); - } catch (...) { - EXPECT_FALSE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtInfo."; - } + string bundleName = BUNDLE_NAME; + string extInfo = "test"; + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto extInfoRet = sessionManagerPtr_->GetBackupExtInfo(bundleName); + EXPECT_EQ(extInfoRet, ""); + + BackupExtInfo info; + info.extInfo = "test"; + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = info; + auto ret = sessionManagerPtr_->GetBackupExtInfo(bundleName); + EXPECT_EQ(ret, "test"); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtInfo_0100"; } @@ -1264,12 +1130,12 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleFileReady_0200, te EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->Deactive(nullptr, true); Init(IServiceReverse::Scenario::BACKUP); - auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_FALSE(ret); - ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); - EXPECT_FALSE(ret); + bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); + EXPECT_FALSE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_FALSE(fileReady); + fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); + EXPECT_FALSE(fileReady); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by OnBundleFileReady."; @@ -1385,25 +1251,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetOldBackupVersion_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleRestoreType_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleRestoreType_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); - EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].restoreType, RESTORE_DATA_READDY); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleRestoreType."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); + EXPECT_TRUE(true); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY); + EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].restoreType, RESTORE_DATA_READDY); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleRestoreType_0100"; } @@ -1419,25 +1276,17 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleRestoreType_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleRestoreType_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleRestoreType_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleRestoreType."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); + EXPECT_TRUE(restoreType == RestoreTypeEnum::RESTORE_DATA_WAIT_SEND); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME); + EXPECT_TRUE(restoreType == RestoreTypeEnum::RESTORE_DATA_WAIT_SEND); + EXPECT_TRUE(true); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleRestoreType_0100"; } @@ -1453,25 +1302,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleRestoreType_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionCode_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionCode_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); - EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].versionCode, 0); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleVersionCode."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); + EXPECT_TRUE(true); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0); + EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].versionCode, 0); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleVersionCode_0100"; } @@ -1487,25 +1327,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionCode_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionCode_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionCode_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleVersionCode."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto versionCode = sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); + EXPECT_TRUE(versionCode == 0); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME); + EXPECT_TRUE(true); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleVersionCode_0100"; } @@ -1522,14 +1353,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionName_0100, { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionName_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0"); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0"); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -1555,25 +1382,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionName_0100, HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionName_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionName_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleVersionName."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto versionStr = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); + EXPECT_EQ(versionStr, ""); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + versionStr = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME); + EXPECT_EQ(versionStr, ""); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleVersionName_0100"; } @@ -1590,17 +1408,13 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Start_0100, testing::ext:: { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Start_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->Start(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + ErrCode ret = sessionManagerPtr_->Start(); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->Start(); + ret = sessionManagerPtr_->Start(); EXPECT_TRUE(sessionManagerPtr_->impl_.isBackupStart); } catch (...) { EXPECT_TRUE(false); @@ -1653,29 +1467,20 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Finish_0100, testing::ext: HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnAllBundlesFinished_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnAllBundlesFinished_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->IsOnAllBundlesFinished(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; - sessionManagerPtr_->IsOnAllBundlesFinished(); - EXPECT_TRUE(true); - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - sessionManagerPtr_->IsOnAllBundlesFinished(); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by IsOnAllBundlesFinished."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + bool ret = sessionManagerPtr_->IsOnAllBundlesFinished(); + EXPECT_FALSE(ret); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + ret = sessionManagerPtr_->IsOnAllBundlesFinished(); + EXPECT_FALSE(ret); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + ret = sessionManagerPtr_->IsOnAllBundlesFinished(); + EXPECT_FALSE(ret); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_IsOnAllBundlesFinished_0100"; } @@ -1692,18 +1497,14 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnOnStartSched_0100, tes { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnOnStartSched_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->IsOnOnStartSched(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->IsOnOnStartSched(); + EXPECT_FALSE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.isBackupStart = false; - auto ret = sessionManagerPtr_->IsOnOnStartSched(); + ret = sessionManagerPtr_->IsOnOnStartSched(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.isBackupStart = true; @@ -1736,14 +1537,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleDataSize_0100, te { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleDataSize_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -1822,7 +1619,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_UpdateTimer_0100, testing: sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); - EXPECT_THROW(sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::TIMEOUT_INVALID, callback), BError); + EXPECT_FALSE(ret); BackupExtInfo info; info.extTimerStatus = false; @@ -1930,23 +1727,14 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_ClearSessionData_0100, tes HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIsIncrementalBackup_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIsIncrementalBackup_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetIsIncrementalBackup(); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + bool ret = sessionManagerPtr_->GetIsIncrementalBackup(); + EXPECT_FALSE(ret); - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->GetIsIncrementalBackup(); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetIsIncrementalBackup."; - } + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + ret = sessionManagerPtr_->GetIsIncrementalBackup(); + EXPECT_FALSE(ret); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIsIncrementalBackup_0100"; } @@ -1964,14 +1752,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIncrementalData_0100, t GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetIncrementalData_0100"; try { BIncrementalData incrementalData; - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetIncrementalData(incrementalData); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetIncrementalData(incrementalData); + EXPECT_TRUE(true); incrementalData.bundleName = BUNDLE_NAME; sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; @@ -1998,25 +1782,16 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIncrementalData_0100, t HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIncrementalManifestFd_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIncrementalManifestFd_0100"; - try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } - - sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.backupExtNameMap.clear(); - sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetIncrementalManifestFd."; - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); + EXPECT_TRUE(ret == -1); + + sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; + ret = sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME); + EXPECT_TRUE(ret == 0); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIncrementalManifestFd_0100"; } @@ -2116,14 +1891,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetClearDataFlag_0100, tes { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetClearDataFlag_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -2153,14 +1924,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetClearDataFlag_0100, tes { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetClearDataFlag_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + auto ret = sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME); + EXPECT_TRUE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); @@ -2190,14 +1957,10 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetPublishFlag_0100, testi { GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetPublishFlag_0100"; try { - try { - EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.clientToken = 0; - sessionManagerPtr_->SetPublishFlag(BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); - } + EXPECT_TRUE(sessionManagerPtr_ != nullptr); + sessionManagerPtr_->impl_.clientToken = 0; + sessionManagerPtr_->SetPublishFlag(BUNDLE_NAME); + EXPECT_TRUE(true); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap.clear(); diff --git a/utils/include/b_resources/b_constants.h b/utils/include/b_resources/b_constants.h index 71253a756..7ad1b2e25 100644 --- a/utils/include/b_resources/b_constants.h +++ b/utils/include/b_resources/b_constants.h @@ -45,6 +45,7 @@ enum ServiceSchedAction { RUNNING = 2, FINISH = 3, CLEAN = 4, + UNKNOWN = 5, }; constexpr int SPAN_USERID_UID = 200000; -- Gitee