From e66abe0eeee5e2e882a0721b4fa5b6b26202c928 Mon Sep 17 00:00:00 2001 From: wangpggg Date: Wed, 9 Oct 2024 11:00:43 +0800 Subject: [PATCH] add ut Signed-off-by: wangpeng --- .../module_external/src/bms_adapter_mock.cpp | 5 + .../include/svc_restore_deps_manager_mock.h | 49 ++ .../module_ipc/include/system_ability_mock.h | 39 ++ .../src/svc_restore_deps_manager_mock.cpp | 48 ++ .../module_ipc/src/system_ability_mock.cpp | 23 + .../b_json_service_disposal_config_mock.h | 47 ++ .../b_json_service_disposal_config_mock.cpp | 47 ++ tests/unittests/backup_sa/module_ipc/BUILD.gn | 19 +- .../module_ipc/service_other_test.cpp | 542 ++++++++++++++---- .../backup_utils/b_filesystem/b_dir_test.cpp | 8 +- 10 files changed, 700 insertions(+), 127 deletions(-) create mode 100644 tests/mock/module_ipc/include/svc_restore_deps_manager_mock.h create mode 100644 tests/mock/module_ipc/include/system_ability_mock.h create mode 100644 tests/mock/module_ipc/src/svc_restore_deps_manager_mock.cpp create mode 100644 tests/mock/module_ipc/src/system_ability_mock.cpp create mode 100644 tests/mock/utils_mock/include/b_json_service_disposal_config_mock.h create mode 100644 tests/mock/utils_mock/src/b_json_service_disposal_config_mock.cpp diff --git a/tests/mock/module_external/src/bms_adapter_mock.cpp b/tests/mock/module_external/src/bms_adapter_mock.cpp index 88984a7cb..ee89521f1 100644 --- a/tests/mock/module_external/src/bms_adapter_mock.cpp +++ b/tests/mock/module_external/src/bms_adapter_mock.cpp @@ -65,4 +65,9 @@ vector BundleMgrAdapter::GetBundleInfosForAppend( { return BBundleMgrAdapter::bms->GetBundleInfosForAppend(incrementalDataList, userId); } + +vector BundleMgrAdapter::GetFullBundleInfos(int32_t userId) +{ + return BBundleMgrAdapter::bms->GetFullBundleInfos(userId); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/module_ipc/include/svc_restore_deps_manager_mock.h b/tests/mock/module_ipc/include/svc_restore_deps_manager_mock.h new file mode 100644 index 000000000..cec7f5eab --- /dev/null +++ b/tests/mock/module_ipc/include/svc_restore_deps_manager_mock.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License") = 0; + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_FILEMGMT_BACKUP_IPC_SVC_RESTORE_DEPS_MANAGER_MOCK_H +#define OHOS_FILEMGMT_BACKUP_IPC_SVC_RESTORE_DEPS_MANAGER_MOCK_H + +#include + +#include "svc_restore_deps_manager.h" + +namespace OHOS::FileManagement::Backup { +class BSvcRestoreDepsManager { +public: + virtual std::vector GetRestoreBundleNames(const std::vector&, + RestoreTypeEnum) = 0; + virtual std::map GetRestoreBundleMap(); + virtual std::vector GetAllBundles() const = 0; + virtual bool IsAllBundlesRestored() const = 0; + virtual bool UpdateToRestoreBundleMap(const std::string&, const std::string&) = 0; +public: + BSvcRestoreDepsManager() = default; + virtual ~BSvcRestoreDepsManager() = default; +public: + static inline std::shared_ptr manager = nullptr; +}; + +class SvcRestoreDepsManagerMock : public BSvcRestoreDepsManager { +public: + MOCK_METHOD((std::vector), GetRestoreBundleNames, ((const std::vector&), + RestoreTypeEnum)); + MOCK_METHOD((std::map), GetRestoreBundleMap, ()); + MOCK_METHOD((std::vector), GetAllBundles, (), (const)); + MOCK_METHOD(bool, IsAllBundlesRestored, (), (const)); + MOCK_METHOD(bool, UpdateToRestoreBundleMap, (const std::string&, const std::string&)); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_IPC_SVC_RESTORE_DEPS_MANAGER_MOCK_H \ No newline at end of file diff --git a/tests/mock/module_ipc/include/system_ability_mock.h b/tests/mock/module_ipc/include/system_ability_mock.h new file mode 100644 index 000000000..8bdc5a402 --- /dev/null +++ b/tests/mock/module_ipc/include/system_ability_mock.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License") = 0; + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_FILEMGMT_BACKUP_SYSTEM_ABILITY_MOCK_H +#define OHOS_FILEMGMT_BACKUP_SYSTEM_ABILITY_MOCK_H + +#include + +#include "system_ability.h" + +namespace OHOS::FileManagement::Backup { +class BSystemAbility { +public: + virtual bool Publish(sptr) = 0; +public: + BSystemAbility() = default; + virtual ~BSystemAbility() = default; +public: + static inline std::shared_ptr ability = nullptr; +}; + +class SystemAbilityMock : public BSystemAbility { +public: + MOCK_METHOD(bool, Publish, (sptr)); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_SYSTEM_ABILITY_MOCK_H \ No newline at end of file diff --git a/tests/mock/module_ipc/src/svc_restore_deps_manager_mock.cpp b/tests/mock/module_ipc/src/svc_restore_deps_manager_mock.cpp new file mode 100644 index 000000000..f9b484fcd --- /dev/null +++ b/tests/mock/module_ipc/src/svc_restore_deps_manager_mock.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "svc_restore_deps_manager_mock.h" + +namespace OHOS::FileManagement::Backup { +using namespace std; + +vector SvcRestoreDepsManager::GetRestoreBundleNames(const vector &bundleInfos, + RestoreTypeEnum restoreType) +{ + return BSvcRestoreDepsManager::manager->GetRestoreBundleNames(bundleInfos, restoreType); +} + +map SvcRestoreDepsManager::GetRestoreBundleMap() +{ + return BSvcRestoreDepsManager::manager->GetRestoreBundleMap(); +} + +void SvcRestoreDepsManager::AddRestoredBundles(const string &bundleName) {} + +vector SvcRestoreDepsManager::GetAllBundles() const +{ + return BSvcRestoreDepsManager::manager->GetAllBundles(); +} + +bool SvcRestoreDepsManager::IsAllBundlesRestored() const +{ + return BSvcRestoreDepsManager::manager->IsAllBundlesRestored(); +} + +bool SvcRestoreDepsManager::UpdateToRestoreBundleMap(const string &bundleName, const string &fileName) +{ + return BSvcRestoreDepsManager::manager->UpdateToRestoreBundleMap(bundleName, fileName); +} +} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/module_ipc/src/system_ability_mock.cpp b/tests/mock/module_ipc/src/system_ability_mock.cpp new file mode 100644 index 000000000..9f72e6d6e --- /dev/null +++ b/tests/mock/module_ipc/src/system_ability_mock.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "system_ability_mock.h" + +namespace OHOS { +bool SystemAbility::Publish(sptr systemAbility) +{ + return OHOS::FileManagement::Backup::BSystemAbility::ability->Publish(systemAbility); +} +} \ No newline at end of file diff --git a/tests/mock/utils_mock/include/b_json_service_disposal_config_mock.h b/tests/mock/utils_mock/include/b_json_service_disposal_config_mock.h new file mode 100644 index 000000000..6e41175b4 --- /dev/null +++ b/tests/mock/utils_mock/include/b_json_service_disposal_config_mock.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_FILEMGMT_BACKUP_B_B_JSON_SERVICE_DISPOSAL_CONFIG_MOCK_H +#define OHOS_FILEMGMT_BACKUP_B_B_JSON_SERVICE_DISPOSAL_CONFIG_MOCK_H + +#include + +#include "b_json/b_json_service_disposal_config.h" + +namespace OHOS::FileManagement::Backup { +class BBJsonDisposalConfig { +public: + virtual bool IfBundleNameInDisposalConfigFile(const std::string&) = 0; + virtual bool AppendIntoDisposalConfigFile(const std::string&) = 0; + virtual bool DeleteFromDisposalConfigFile(const std::string&) = 0; + virtual std::vector GetBundleNameFromConfigFile() = 0; + virtual bool DeleteConfigFile(); +public: + BBJsonDisposalConfig() = default; + virtual ~BBJsonDisposalConfig() = default; +public: + static inline std::shared_ptr config = nullptr; +}; + +class BJsonDisposalConfigMock : public BBJsonDisposalConfig { +public: + MOCK_METHOD(bool, IfBundleNameInDisposalConfigFile, (const std::string&)); + MOCK_METHOD(bool, AppendIntoDisposalConfigFile, (const std::string&)); + MOCK_METHOD(bool, DeleteFromDisposalConfigFile, (const std::string&)); + MOCK_METHOD((std::vector), GetBundleNameFromConfigFile, ()); + MOCK_METHOD(bool, DeleteConfigFile, ()); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_B_B_JSON_SERVICE_DISPOSAL_CONFIG_MOCK_H diff --git a/tests/mock/utils_mock/src/b_json_service_disposal_config_mock.cpp b/tests/mock/utils_mock/src/b_json_service_disposal_config_mock.cpp new file mode 100644 index 000000000..20cb7ba6c --- /dev/null +++ b/tests/mock/utils_mock/src/b_json_service_disposal_config_mock.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "b_json_service_disposal_config_mock.h" + +namespace OHOS::FileManagement::Backup { +using namespace std; + +BJsonDisposalConfig::BJsonDisposalConfig() {} + +bool BJsonDisposalConfig::AppendIntoDisposalConfigFile(const string& bundleName) +{ + return BBJsonDisposalConfig::config->AppendIntoDisposalConfigFile(bundleName); +} + +bool BJsonDisposalConfig::DeleteFromDisposalConfigFile(const string& bundleName) +{ + return BBJsonDisposalConfig::config->DeleteFromDisposalConfigFile(bundleName); +} + +bool BJsonDisposalConfig::IfBundleNameInDisposalConfigFile(const string& bundleName) +{ + return BBJsonDisposalConfig::config->IfBundleNameInDisposalConfigFile(bundleName); +} + +vector BJsonDisposalConfig::GetBundleNameFromConfigFile() +{ + return BBJsonDisposalConfig::config->GetBundleNameFromConfigFile(); +} + +bool BJsonDisposalConfig::DeleteConfigFile() +{ + return BBJsonDisposalConfig::config->DeleteConfigFile(); +} +} // namespace OHOS::FileManagement::Backup diff --git a/tests/unittests/backup_sa/module_ipc/BUILD.gn b/tests/unittests/backup_sa/module_ipc/BUILD.gn index a71ade0a8..fd96fa960 100644 --- a/tests/unittests/backup_sa/module_ipc/BUILD.gn +++ b/tests/unittests/backup_sa/module_ipc/BUILD.gn @@ -465,32 +465,39 @@ ohos_unittest("backup_service_other_test") { module_out_path = path_module_out_tests sources = [ - "${path_backup_mock}/accesstoken/accesstoken_kit_mock.cpp", - "${path_backup_mock}/module_external/bms_adapter_mock.cpp", + "${path_backup_mock}/accesstoken/src/accesstoken_kit_mock.cpp", + "${path_backup_mock}/module_external/src/bms_adapter_mock.cpp", "${path_backup_mock}/module_external/src/sms_adapter_mock.cpp", - "${path_backup_mock}/module_ipc/app_gallery_dispose_proxy_mock.cpp", + "${path_backup_mock}/module_ipc/src/app_gallery_dispose_proxy_mock.cpp", "${path_backup_mock}/module_ipc/src/ipc_skeleton_mock.cpp", + "${path_backup_mock}/module_ipc/src/notify_work_service_mock.cpp", "${path_backup_mock}/module_ipc/src/sa_backup_connection_mock.cpp", "${path_backup_mock}/module_ipc/src/service_stub_mock.cpp", "${path_backup_mock}/module_ipc/src/svc_backup_connection_mock.cpp", + "${path_backup_mock}/module_ipc/src/svc_restore_deps_manager_mock.cpp", "${path_backup_mock}/module_ipc/src/svc_session_manager_mock.cpp", + "${path_backup_mock}/module_ipc/src/system_ability_mock.cpp", "${path_backup_mock}/module_sched/sched_scheduler_mock.cpp", + "${path_backup_mock}/utils_mock/src/b_json_clear_data_config_mock.cpp", + "${path_backup_mock}/utils_mock/src/b_json_service_disposal_config_mock.cpp", + "${path_backup_mock}/utils_mock/src/b_jsonutil_mock.cpp", + "${path_backup_mock}/utils_mock/src/b_sa_utils_mock.cpp", "${path_backup_mock}/utils_mock/src/backup_para_mock.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/service_incremental.cpp", "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp", "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_restore_deps_manager.cpp", - "${path_backup}/services/backup_sa/src/module_notify/notify_work_service.cpp", "service_other_test.cpp", ] include_dirs = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/services/backup_sa/include", + "${path_backup}/services/backup_sa/include/module_app_gallery", "${path_backup}/services/backup_sa/include/module_ipc", + "${path_backup}/services/backup_sa/include/module_notify", "${path_backup}/services/backup_sa/src/module_ipc", "${path_backup}/tests/unittests/backup_api/backup_impl/include", "${path_backup}/tests/utils/include/", + "${path_backup_mock}/accesstoken/include", "${path_backup_mock}/module_external/include", "${path_backup_mock}/module_ipc/include", "${path_backup_mock}/utils_mock/include", diff --git a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp index ecd19d25a..dff389501 100644 --- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp @@ -15,23 +15,102 @@ #include #include -#include -#include +#include "accesstoken_kit_mock.h" #include "backup_para_mock.h" #include "bms_adapter_mock.h" +#include "b_json_clear_data_config_mock.h" +#include "b_json_service_disposal_config_mock.h" #include "b_jsonutil_mock.h" +#include "b_sa_utils_mock.h" #include "ipc_skeleton_mock.h" #include "sa_backup_connection_mock.h" #include "service_reverse_proxy_mock.h" #include "svc_backup_connection_mock.h" #include "svc_extension_proxy_mock.h" +#include "svc_restore_deps_manager_mock.h" #include "svc_session_manager_mock.h" +#include "system_ability_mock.h" -#include "module_ipc/service.h" #include "service.cpp" #include "sub_service.cpp" +namespace OHOS::FileManagement::Backup { +ErrCode Service::Release() +{ + return BError(BError::Codes::OK); +} + +UniqueFd Service::GetLocalCapabilitiesIncremental(const std::vector&) +{ + return UniqueFd(-1); +} + +void Service::StartGetFdTask(std::string, wptr) {} + +ErrCode Service::GetAppLocalListAndDoIncrementalBackup() +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::InitIncrementalBackupSession(sptr) +{ + return BError(BError::Codes::OK); +} + +vector Service::GetBundleNameByDetails(const std::vector&) +{ + return {}; +} + +ErrCode Service::AppendBundlesIncrementalBackupSession(const std::vector&) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::AppendBundlesIncrementalBackupSession(const std::vector&, + const std::vector&) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::PublishIncrementalFile(const BFileInfo&) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::PublishSAIncrementalFile(const BFileInfo&, UniqueFd) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::AppIncrementalFileReady(const std::string&, UniqueFd, UniqueFd, int32_t) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::AppIncrementalDone(ErrCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::GetIncrementalFileHandle(const std::string&, const std::string&) +{ + return BError(BError::Codes::OK); +} + +bool Service::IncrementalBackup(const string&) +{ + return false; +} + +void Service::NotifyCallerCurAppIncrementDone(ErrCode, const std::string&) {} + +void Service::SendUserIdToApp(string&, int32_t) {} + +void Service::SetCurrentBackupSessProperties(const vector&, int32_t) {} +} + namespace OHOS::FileManagement::Backup { using namespace std; using namespace testing; @@ -47,7 +126,7 @@ public: void SetUp() {}; void TearDown() {}; - static inline sptr servicePtr_ = nullptr; + static inline sptr service = nullptr; static inline shared_ptr param = nullptr; static inline shared_ptr jsonUtil = nullptr; static inline shared_ptr session = nullptr; @@ -57,12 +136,18 @@ public: static inline shared_ptr saConnect = nullptr; static inline shared_ptr skeleton = nullptr; static inline sptr srProxy = nullptr; + static inline shared_ptr cdConfig = nullptr; + static inline shared_ptr saUtils = nullptr; + static inline shared_ptr token = nullptr; + static inline shared_ptr jdConfig = nullptr; + static inline shared_ptr ability = nullptr; + static inline shared_ptr depManager = nullptr; }; void ServiceTest::SetUpTestCase(void) { GTEST_LOG_(INFO) << "SetUpTestCase enter"; - servicePtr_ = sptr(new Service(SERVICE_ID)); + service = sptr(new Service(SERVICE_ID)); param = make_shared(); BackupParaMock::backupPara = param; jsonUtil = make_shared(); @@ -79,12 +164,24 @@ void ServiceTest::SetUpTestCase(void) skeleton = make_shared(); IPCSkeletonMock::skeleton = skeleton; srProxy = sptr(new ServiceReverseProxyMock()); + cdConfig = make_shared(); + BJsonClearDataConfigMock::config = cdConfig; + saUtils = make_shared(); + SAUtilsMock::utils = saUtils; + token = make_shared(); + AccessTokenKitMock::token = token; + jdConfig = make_shared(); + BJsonDisposalConfigMock::config = jdConfig; + ability = make_shared(); + SystemAbilityMock::ability = ability; + depManager = make_shared(); + SvcRestoreDepsManagerMock::manager = depManager; } void ServiceTest::TearDownTestCase() { GTEST_LOG_(INFO) << "TearDownTestCase enter"; - servicePtr_ = nullptr; + service = nullptr; BackupParaMock::backupPara = nullptr; param = nullptr; BJsonUtilMock::jsonUtil = nullptr; @@ -101,6 +198,191 @@ void ServiceTest::TearDownTestCase() IPCSkeletonMock::skeleton = nullptr; skeleton = nullptr; srProxy = nullptr; + BJsonClearDataConfigMock::config = nullptr; + cdConfig = nullptr; + SAUtilsMock::utils = nullptr; + saUtils = nullptr; + AccessTokenKitMock::token = nullptr; + token = nullptr; + BJsonDisposalConfigMock::config = nullptr; + jdConfig = nullptr; + SystemAbilityMock::ability = nullptr; + ability = nullptr; + SvcRestoreDepsManagerMock::manager = nullptr; + depManager = nullptr; +} + +/** + * @tc.number: SUB_Service_GetUserIdDefault_0000 + * @tc.name: SUB_Service_GetUserIdDefault_0000 + * @tc.desc: 测试 GetUserIdDefault 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_GetUserIdDefault_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetUserIdDefault_0000"; + try { + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = GetUserIdDefault(); + EXPECT_EQ(ret, DEBUG_ID + 1); + + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + ret = GetUserIdDefault(); + EXPECT_EQ(ret, BConstants::DEFAULT_USER_ID); + + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(true, 0))); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + ret = GetUserIdDefault(); + EXPECT_EQ(ret, BConstants::DEFAULT_USER_ID); + + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::XTS_UID)); + ret = GetUserIdDefault(); + EXPECT_EQ(ret, BConstants::DEFAULT_USER_ID); + + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); + EXPECT_CALL(*skeleton, GetCallingUid()) + .WillOnce(Return(BConstants::SPAN_USERID_UID + BConstants::SPAN_USERID_UID)); + ret = GetUserIdDefault(); + EXPECT_EQ(ret, 2); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetUserIdDefault."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetUserIdDefault_0000"; +} + +/** + * @tc.number: SUB_Service_OnStart_0100 + * @tc.name: SUB_Service_OnStart_0100 + * @tc.desc: 测试 OnStart + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_OnStart_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStart_0100"; + try { + vector bundleNames; + auto disposal = service->disposal_; + auto clearRecorder = service->clearRecorder_; + auto sched_ = service->sched_; + service->disposal_ = nullptr; + service->clearRecorder_ = nullptr; + service->sched_ = nullptr; + service->isOccupyingSession_ = false; + + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames)); + service->OnStart(); + EXPECT_TRUE(true); + + service->disposal_ = disposal; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames)) + .WillOnce(Return(bundleNames)); + service->OnStart(); + EXPECT_TRUE(true); + + service->clearRecorder_ = clearRecorder; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames)) + .WillOnce(Return(bundleNames)); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(bundleNames)); + service->OnStart(); + EXPECT_TRUE(true); + + service->sched_ = sched_; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames)) + .WillOnce(Return(bundleNames)); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(bundleNames)); + service->OnStart(); + EXPECT_TRUE(true); + + service->isOccupyingSession_ = false; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNames)) + .WillOnce(Return(bundleNames)); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(bundleNames)); + service->OnStart(); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnStart."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnStart_0100"; +} + +/** + * @tc.number: SUB_Service_OnStart_0200 + * @tc.name: SUB_Service_OnStart_0200 + * @tc.desc: 测试 OnStart + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_OnStart_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStart_0200"; + try { + service->isOccupyingSession_ = true; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector())) + .WillOnce(Return(vector())); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector())); + service->OnStart(); + EXPECT_TRUE(true); + + service->isOccupyingSession_ = false; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector(1))) + .WillOnce(Return(vector())); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector())); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + service->OnStart(); + EXPECT_TRUE(true); + + auto session_ = service->session_; + service->session_ = nullptr; + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector())) + .WillOnce(Return(vector())); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector(1))); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + service->OnStart(); + EXPECT_TRUE(true); + + EXPECT_CALL(*ability, Publish(_)).WillOnce(Return(false)); + EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(vector(1))) + .WillOnce(Return(vector())); + EXPECT_CALL(*cdConfig, GetAllClearBundleRecords()).WillOnce(Return(vector(1))); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + service->OnStart(); + service->session_ = session_; + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnStart."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnStart_0200"; } /** @@ -116,16 +398,16 @@ HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilities_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilities_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); - servicePtr_->session_ = nullptr; - UniqueFd fd = servicePtr_->GetLocalCapabilities(); + ASSERT_TRUE(service != nullptr); + service->session_ = nullptr; + UniqueFd fd = service->GetLocalCapabilities(); EXPECT_NE(fd, BError(BError::Codes::OK)); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); - servicePtr_->isOccupyingSession_.store(true); - fd = servicePtr_->GetLocalCapabilities(); + service->session_ = sptr(new SvcSessionManager(wptr(service))); + service->isOccupyingSession_.store(true); + fd = service->GetLocalCapabilities(); EXPECT_NE(fd, BError(BError::Codes::OK)); - servicePtr_->isOccupyingSession_.store(false); + service->isOccupyingSession_.store(false); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetLocalCapabilities."; @@ -146,29 +428,21 @@ HWTEST_F(ServiceTest, SUB_Service_AppendBundlesRestoreSession_0100, TestSize.Lev { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesRestoreSession_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); - EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) - .WillOnce(Return(make_pair(false, 0))) - .WillOnce(Return(make_pair(false, 0))); - EXPECT_CALL(*skeleton, GetCallingUid()) - .WillOnce(Return(BConstants::SYSTEM_UID)) - .WillOnce(Return(BConstants::SYSTEM_UID)); - EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); - UniqueFd fd = servicePtr_->GetLocalCapabilities(); + ASSERT_TRUE(service != nullptr); std::vector bundleNames; std::vector bundleInfos; RestoreTypeEnum restoreType = RESTORE_DATA_READDY; int32_t userId = 100; - servicePtr_->session_ = nullptr; - auto ret = servicePtr_->AppendBundlesRestoreSession(move(fd), bundleNames, bundleInfos, restoreType, userId); - EXPECT_NE(ret, BError(BError::Codes::OK)); + service->session_ = nullptr; + auto ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, bundleInfos, restoreType, userId); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); - servicePtr_->isOccupyingSession_.store(true); - ret = servicePtr_->AppendBundlesRestoreSession(move(fd), bundleNames, bundleInfos, restoreType, userId); - EXPECT_NE(ret, BError(BError::Codes::OK)); - servicePtr_->isOccupyingSession_.store(false); + service->session_ = sptr(new SvcSessionManager(wptr(service))); + service->isOccupyingSession_.store(true); + ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, bundleInfos, restoreType, userId); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); + service->isOccupyingSession_.store(false); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesRestoreSession."; @@ -189,27 +463,23 @@ HWTEST_F(ServiceTest, SUB_Service_AppendBundlesRestoreSession_0200, TestSize.Lev { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesRestoreSession_0200"; try { - EXPECT_TRUE(servicePtr_ != nullptr); - EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) - .WillOnce(Return(make_pair(false, 0))) - .WillOnce(Return(make_pair(false, 0))); - EXPECT_CALL(*skeleton, GetCallingUid()) - .WillOnce(Return(BConstants::SYSTEM_UID)) - .WillOnce(Return(BConstants::SYSTEM_UID)); - EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); - UniqueFd fd = servicePtr_->GetLocalCapabilities(); - std::vector bundleNames; - std::vector bundleInfos; + ASSERT_TRUE(service != nullptr); + vector bundleInfos; + vector bundleNames; + vector infos; RestoreTypeEnum restoreType = RESTORE_DATA_READDY; int32_t userId = DEFAULT_INVAL_VALUE; - + map> bundleNameDetailMap; + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); - EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); - EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false)); - auto ret = servicePtr_->AppendBundlesRestoreSession(move(fd), bundleNames, bundleInfos, restoreType, userId); - EXPECT_EQ(ret, BError(BError::Codes::OK)); + EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap)); + EXPECT_CALL(*bms, GetBundleInfos(_, _)).WillOnce(Return(infos)); + auto ret = service->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, bundleInfos, restoreType, userId); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesRestoreSession."; @@ -230,18 +500,19 @@ HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0100, TestSize.Level1 { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SetCurrentSessProperties_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); BJsonEntityCaps::BundleInfo info; - std::map isClearDataFlags; - std::string bundleNameIndexInfo = BJsonUtil::BuildBundleNameIndexInfo(info.name, info.appIndex); - servicePtr_->session_ = nullptr; - servicePtr_->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); - servicePtr_->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo); + map isClearDataFlags; + string bundleNameIndexInfo; + + service->session_ = nullptr; + service->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo); + service->session_ = sptr(new SvcSessionManager(wptr(service))); + service->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo); info = BJsonEntityCaps::BundleInfo{BUNDLE_NAME, 0, {}, {}, 0, 0, true, false, BUNDLE_NAME}; isClearDataFlags = {{BUNDLE_NAME, true}}; - servicePtr_->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo); + service->SetCurrentSessProperties(info, isClearDataFlags, bundleNameIndexInfo); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetCurrentSessProperties."; @@ -262,18 +533,17 @@ HWTEST_F(ServiceTest, SUB_Service_AppendBundlesBackupSession_0100, TestSize.Leve { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesBackupSession_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); std::vector bundleNames; - servicePtr_->session_ = nullptr; - auto ret = servicePtr_->AppendBundlesBackupSession(bundleNames); + service->session_ = nullptr; + auto ret = service->AppendBundlesBackupSession(bundleNames); EXPECT_NE(ret, BError(BError::Codes::OK)); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); - servicePtr_->isOccupyingSession_.store(true); - ret = servicePtr_->AppendBundlesBackupSession(bundleNames); + service->session_ = sptr(new SvcSessionManager(wptr(service))); + service->isOccupyingSession_.store(true); + ret = service->AppendBundlesBackupSession(bundleNames); EXPECT_NE(ret, BError(BError::Codes::OK)); - servicePtr_->isOccupyingSession_.store(false); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesBackupSession."; @@ -294,13 +564,17 @@ HWTEST_F(ServiceTest, SUB_Service_AppendBundlesBackupSession_0200, TestSize.Leve { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesBackupSession_0200"; try { - EXPECT_TRUE(servicePtr_ != nullptr); - std::vector bundleNames; - + ASSERT_TRUE(service != nullptr); + vector bundleNames; + vector bundleInfos; + service->isOccupyingSession_.store(false); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*bms, GetBundleInfosForAppend(_, _)).WillOnce(Return(bundleInfos)); EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false)); - auto ret = servicePtr_->AppendBundlesBackupSession(bundleNames); + auto ret = service->AppendBundlesBackupSession(bundleNames); EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -323,19 +597,19 @@ HWTEST_F(ServiceTest, SUB_Service_AppendBundlesDetailsBackupSession_0100, TestSi { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesDetailsBackupSession_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); std::vector bundleNames; std::vector bundleInfos; - servicePtr_->session_ = nullptr; - auto ret = servicePtr_->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); + service->session_ = nullptr; + auto ret = service->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); EXPECT_NE(ret, BError(BError::Codes::OK)); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); - servicePtr_->isOccupyingSession_.store(true); - ret = servicePtr_->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); + service->session_ = sptr(new SvcSessionManager(wptr(service))); + service->isOccupyingSession_.store(true); + ret = service->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); EXPECT_NE(ret, BError(BError::Codes::OK)); - servicePtr_->isOccupyingSession_.store(false); + service->isOccupyingSession_.store(false); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppendBundlesDetailsBackupSession."; @@ -356,14 +630,19 @@ HWTEST_F(ServiceTest, SUB_Service_AppendBundlesDetailsBackupSession_0200, TestSi { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppendBundlesDetailsBackupSession_0200"; try { - EXPECT_TRUE(servicePtr_ != nullptr); - std::vector bundleNames; - std::vector bundleInfos; - + ASSERT_TRUE(service != nullptr); + vector bundleNames; + vector bundleInfos; + vector infos; + map> bundleNameDetailMap; EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap)); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*bms, GetBundleInfosForAppend(_, _)).WillOnce(Return(infos)); EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false)); - auto ret = servicePtr_->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); + auto ret = service->AppendBundlesDetailsBackupSession(bundleNames, bundleInfos); EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -385,26 +664,32 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_PublishFile_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); BFileInfo fileInfo {BUNDLE_NAME, "", 0}; EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - auto ret = servicePtr_->PublishFile(fileInfo); + auto ret = service->PublishFile(fileInfo); EXPECT_NE(ret, BError(BError::Codes::OK)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - ret = servicePtr_->PublishFile(fileInfo); + ret = service->PublishFile(fileInfo); EXPECT_NE(ret, BError(BError::Codes::OK)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*svcProxy, PublishFile(_)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); - ret = servicePtr_->PublishFile(fileInfo); + ret = service->PublishFile(fileInfo); EXPECT_NE(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -426,18 +711,21 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppDone_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); ErrCode errCode = BError(BError::Codes::OK).GetCode(); - servicePtr_->session_ = nullptr; - auto ret = servicePtr_->AppDone(errCode); + service->session_ = nullptr; + auto ret = service->AppDone(errCode); EXPECT_NE(ret, BError(BError::Codes::OK)); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); + service->session_ = sptr(new SvcSessionManager(wptr(service))); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)).WillOnce(Return(false)); - ret = servicePtr_->AppDone(errCode); + ret = service->AppDone(errCode); EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -459,21 +747,27 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0200, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppDone_0200"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); ErrCode errCode = BError(BError::Codes::SA_INVAL_ARG).GetCode(); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - auto ret = servicePtr_->AppDone(errCode); + auto ret = service->AppDone(errCode); EXPECT_NE(ret, BError(BError::Codes::OK)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - ret = servicePtr_->AppDone(errCode); + ret = service->AppDone(errCode); EXPECT_NE(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -495,26 +789,31 @@ HWTEST_F(ServiceTest, SUB_Service_NotifyCloneBundleFinish_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NotifyCloneBundleFinish_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); std::string bundleName = BUNDLE_NAME; BackupRestoreScenario senario = BackupRestoreScenario::INCREMENTAL_BACKUP; - servicePtr_->NotifyCloneBundleFinish(bundleName, senario); + service->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_TRUE(true); senario = BackupRestoreScenario::FULL_RESTORE; EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)) - .WillOnce(Return(false)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); - servicePtr_->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); + service->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_TRUE(true); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - servicePtr_->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); + service->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_TRUE(true); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - servicePtr_->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); + service->NotifyCloneBundleFinish(bundleName, senario); + EXPECT_TRUE(true); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by NotifyCloneBundleFinish."; @@ -535,23 +834,28 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupExtension_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); std::string bundleName = ""; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); - auto ret = servicePtr_->LaunchBackupExtension(bundleName); - EXPECT_NE(ret, BError(BError::Codes::OK)); + auto ret = service->LaunchBackupExtension(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); + BJsonUtil::BundleDetailInfo info; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0)); EXPECT_CALL(*session, GetBundleRestoreType(_)).WillOnce(Return(RestoreTypeEnum::RESTORE_DATA_READDY)); EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - ret = servicePtr_->LaunchBackupExtension(bundleName); - EXPECT_NE(ret, BError(BError::Codes::OK)); + ret = service->LaunchBackupExtension(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0)); @@ -560,8 +864,8 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, TestSize.Level1) EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true)); EXPECT_CALL(*connect, WaitDisconnectDone()).WillOnce(Return(false)); - ret = servicePtr_->LaunchBackupExtension(bundleName); - EXPECT_NE(ret, BError(BError::Codes::OK)); + ret = service->LaunchBackupExtension(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by LaunchBackupExtension."; @@ -582,10 +886,12 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0200, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupExtension_0200"; try { - EXPECT_TRUE(servicePtr_ != nullptr); - std::string bundleName = ""; - + ASSERT_TRUE(service != nullptr); + string bundleName = ""; + BJsonUtil::BundleDetailInfo info; EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0)); @@ -596,10 +902,12 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0200, TestSize.Level1) EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); - auto ret = servicePtr_->LaunchBackupExtension(bundleName); - EXPECT_NE(ret, BError(BError::Codes::OK)); + auto ret = service->LaunchBackupExtension(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL)); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionName(_)).WillOnce(Return("")); EXPECT_CALL(*session, GetBundleVersionCode(_)).WillOnce(Return(0)); @@ -611,8 +919,8 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0200, TestSize.Level1) EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); EXPECT_CALL(*connect, ConnectBackupExtAbility(_, _)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); - ret = servicePtr_->LaunchBackupExtension(bundleName); - EXPECT_NE(ret, BError(BError::Codes::OK)); + ret = service->LaunchBackupExtension(bundleName); + EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by LaunchBackupExtension."; @@ -633,15 +941,15 @@ HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ClearResidualBundleData_0100"; try { - EXPECT_TRUE(servicePtr_ != nullptr); + ASSERT_TRUE(service != nullptr); std::string bundleName = BUNDLE_NAME; - servicePtr_->session_ = nullptr; - servicePtr_->ClearResidualBundleData(bundleName); - servicePtr_->session_ = sptr(new SvcSessionManager(wptr(servicePtr_))); + service->session_ = nullptr; + service->ClearResidualBundleData(bundleName); + service->session_ = sptr(new SvcSessionManager(wptr(service))); try { EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); - servicePtr_->ClearResidualBundleData(bundleName); + service->ClearResidualBundleData(bundleName); EXPECT_TRUE(false); } catch (...) { EXPECT_TRUE(true); @@ -650,7 +958,7 @@ HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0100, TestSize.Level1) try { EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); - servicePtr_->ClearResidualBundleData(bundleName); + service->ClearResidualBundleData(bundleName); EXPECT_TRUE(false); } catch (...) { EXPECT_TRUE(true); diff --git a/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp b/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp index 531a63406..42f8cde99 100644 --- a/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp +++ b/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp @@ -133,20 +133,20 @@ HWTEST_F(BDirTest, b_dir_GetBigFiles_0100, testing::ext::TestSize.Level1) string rootDir = tm.GetRootDirCurTest(); string filePath1 = rootDir + "a.txt"; string filePath2 = rootDir + "b.txt"; - // 文件大小大于等于1GB（1024MB）的文件属于大文件，因此这里创建大小为1025MB和1026MB的大文件 + // 文件大小大于2M的文件属于大文件，因此这里创建大小为3MB文件和4MB的文件 auto [bFatalErr, ret] = - BProcess::ExecuteCmd({"dd", "if=/dev/urandom", ("of=" + filePath1).c_str(), "bs=1M", "count=1025"}); + BProcess::ExecuteCmd({"dd", "if=/dev/urandom", ("of=" + filePath1).c_str(), "bs=1M", "count=3"}); EXPECT_FALSE(bFatalErr); EXPECT_EQ(ret, 0); tie(bFatalErr, ret) = - BProcess::ExecuteCmd({"dd", "if=/dev/urandom", ("of=" + filePath2).c_str(), "bs=1M", "count=1026"}); + BProcess::ExecuteCmd({"dd", "if=/dev/urandom", ("of=" + filePath2).c_str(), "bs=1M", "count=4"}); EXPECT_FALSE(bFatalErr); EXPECT_EQ(ret, 0); vector includes = {rootDir}; vector excludes = {filePath2}; auto [errCode, mpNameToStat, smallFiles] = BDir::GetBigFiles(includes, excludes); EXPECT_EQ(errCode, ERR_OK); - EXPECT_EQ(mpNameToStat.at(filePath1).st_size, 1024 * 1024 * 1025); + EXPECT_EQ(mpNameToStat.at(filePath1).st_size, 1024 * 1024 * 3); EXPECT_EQ(mpNameToStat.find(filePath2), mpNameToStat.end()); } catch (...) { EXPECT_TRUE(false); -- Gitee