From 191f4ce2688c13c5c57457de8f90c5bf0d2b3831 Mon Sep 17 00:00:00 2001 From: hunili Date: Wed, 10 Sep 2025 19:47:18 +0800 Subject: [PATCH] =?UTF-8?q?[Bug]:=20=E4=BA=91=E7=9B=98=5F002=20https://git?= =?UTF-8?q?ee.com/openharmony/filemanagement=5Fuser=5Ffile=5Fservice/issue?= =?UTF-8?q?s/ICXEJJ?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hunili --- bundle.json | 24 +- filemanagement_aafwk.gni | 3 +- .../inner_api/cloud_disk_kit_inner/BUILD.gn | 149 ++++ .../include/cloud_disk_js_manager.h | 30 + .../include/cloud_disk_sync_folder_manager.h | 37 + .../cloud_disk_sync_folder_manager_impl.h | 37 + .../src/cloud_disk_js_manager.cpp | 81 +++ .../src/cloud_disk_sync_folder_manager.cpp | 26 + .../cloud_disk_sync_folder_manager_impl.cpp | 282 ++++++++ services/BUILD.gn | 4 + services/IFileAccessServiceBase.idl | 2 + services/file_access_service.cfg | 5 +- .../src/cloud_disk_service.cpp | 66 +- .../include/file_access_service.h | 4 +- .../src/file_access_service.cpp | 2 +- test/unittest/BUILD.gn | 134 ++++ test/unittest/cloud_disk_js_manager_test.cpp | 70 ++ test/unittest/cloud_disk_service_test.cpp | 42 +- .../cloud_disk_sync_folder_manager_test.cpp | 668 ++++++++++++++++++ .../js_file_access_ext_ability_test.cpp | 10 + test/unittest/mock/file_access_service_mock.h | 2 + utils/file_access_framework_errno.h | 18 +- 22 files changed, 1671 insertions(+), 25 deletions(-) create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/BUILD.gn create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_js_manager.h create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager.h create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager_impl.h create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_js_manager.cpp create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager.cpp create mode 100644 interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager_impl.cpp create mode 100644 test/unittest/cloud_disk_js_manager_test.cpp create mode 100644 test/unittest/cloud_disk_sync_folder_manager_test.cpp diff --git a/bundle.json b/bundle.json index af66ffd0..c601ad44 100644 --- a/bundle.json +++ b/bundle.json @@ -14,7 +14,11 @@ "subsystem": "filemanagement", "syscap": [ "SystemCapability.FileManagement.UserFileService", - "SystemCapability.FileManagement.UserFileService.FolderSelection" + "SystemCapability.FileManagement.UserFileService.FolderSelection", + "SystemCapability.FileManagement.CloudDiskManager" + ], + "features": [ + "user_file_service_cloud_disk_enable" ], "adapted_system_type": [ "standard" @@ -82,6 +86,24 @@ "header_files": [], "header_base": "//foundation/filemanagement/user_file_service/interfaces/kits/picker/cj/include" } + }, + { + "name": "//foundation/filemanagement/user_file_service/interfaces/inner_api/cloud_disk_kit_inner:cloud_disk_manager_kit", + "header": { + "header_files": [ + "cloud_disk_sync_folder_manager.h" + ], + "header_base": "//foundation/filemanagement/user_file_service/interfaces/inner_api/cloud_disk_kit_inner/include" + } + }, + { + "name": "//foundation/filemanagement/user_file_service/interfaces/inner_api/cloud_disk_kit_inner:cloud_disk_manager_js_kit", + "header": { + "header_files": [ + "cloud_disk_js_manager.h" + ], + "header_base": "//foundation/filemanagement/user_file_service/interfaces/inner_api/cloud_disk_kit_inner/include" + } } ], "test": [ diff --git a/filemanagement_aafwk.gni b/filemanagement_aafwk.gni index 92a939f8..9d0c94b5 100644 --- a/filemanagement_aafwk.gni +++ b/filemanagement_aafwk.gni @@ -1,4 +1,4 @@ -# Copyright (c) 2022 Huawei Device Co., Ltd. +# Copyright (c) 2022-2025 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -21,4 +21,5 @@ declare_args() { if (defined(global_parts_info) && !defined(global_parts_info.distributeddatamgr_udmf)) { picker_udmf_enabled = false } + user_file_service_cloud_disk_enable = false } \ No newline at end of file diff --git a/interfaces/inner_api/cloud_disk_kit_inner/BUILD.gn b/interfaces/inner_api/cloud_disk_kit_inner/BUILD.gn new file mode 100644 index 00000000..5a2cbcdc --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/BUILD.gn @@ -0,0 +1,149 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/components/idl_tool/idl.gni") +import("//build/ohos.gni") +import("//foundation/filemanagement/user_file_service/filemanagement_aafwk.gni") + +config("cloud_disk_public_config") { + include_dirs = [ "include" ] +} + +ohos_shared_library("cloud_disk_manager_js_kit") { + branch_protector_ret = "pac_ret" + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + } + + public_configs = [":cloud_disk_public_config"] + + include_dirs = [ + "${user_file_service_path}/services/native/file_access_service/include", + "${user_file_service_path}/utils/file_access_framework_errno.h", + "include" + ] + + deps = [ + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_ext_base_source", + "${user_file_service_path}/services:file_access_service_base_source" + ] + + sources = [ + "${user_file_service_path}/services/native/file_access_service/src/file_access_service_client.cpp", + "${user_file_service_path}/interfaces/inner_api/file_access/src/uri_ext.cpp", + "src/cloud_disk_comm.cpp", + "src/cloud_disk_js_manager.cpp" + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:extensionkit_native", + "ability_runtime:napi_common", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "file_api:filemgmt_libn", + "hilog:libhilog", + "hitrace:hitrace_meter", + "init:libbegetutil", + "ipc:ipc_core", + "ipc:ipc_napi", + "napi:ace_napi", + "os_account:os_account_innerkits", + "samgr:samgr_proxy", + ] + + if (user_file_service_cloud_disk_enable) { + defines = ["SUPPORT_CLOUD_DISK_MANAGER"] + } + + subsystem_name = "filemanagement" + part_name = "user_file_service" + innerapi_tags = [ "platformsdk" ] +} + +ohos_shared_library("cloud_disk_manager_kit") { + branch_protector_ret = "pac_ret" + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + } + + include_dirs = [ + "${user_file_service_path}/services/native/file_access_service/include", + ] + + public_configs = [":cloud_disk_public_config"] + + deps = [ + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_ext_base_source", + "${user_file_service_path}/services:file_access_service_base_source" + ] + + sources = [ + "${user_file_service_path}/services/native/file_access_service/src/file_access_service_client.cpp", + "${user_file_service_path}/interfaces/inner_api/file_access/src/uri_ext.cpp", + "src/cloud_disk_comm.cpp", + "src/cloud_disk_sync_folder_manager.cpp", + "src/cloud_disk_sync_folder_manager_impl.cpp" + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:extensionkit_native", + "ability_runtime:napi_common", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "file_api:filemgmt_libn", + "hilog:libhilog", + "hitrace:hitrace_meter", + "init:libbegetutil", + "ipc:ipc_core", + "ipc:ipc_napi", + "napi:ace_napi", + "os_account:os_account_innerkits", + "samgr:samgr_proxy", + ] + + if (user_file_service_cloud_disk_enable) { + defines = ["SUPPORT_CLOUD_DISK_MANAGER"] + } + + subsystem_name = "filemanagement" + part_name = "user_file_service" + innerapi_tags = [ "platformsdk" ] +} \ No newline at end of file diff --git a/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_js_manager.h b/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_js_manager.h new file mode 100644 index 00000000..bda492c7 --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_js_manager.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef CLOUD_DISK_MANAGER_JS_H +#define CLOUD_DISK_MANAGER_JS_H + +#include "cloud_disk_comm.h" + +namespace OHOS { +namespace FileManagement { +class CloudDiskJSManager { +public: + CloudDiskJSManager() = default; + ~CloudDiskJSManager() = default; + int GetAllSyncFolders(std::vector &syncFolderExts); +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // CLOUD_DISK_MANAGER_JS_H diff --git a/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager.h b/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager.h new file mode 100644 index 00000000..1c0d6bff --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef CLOUD_DISK_SYNC_FOLDER_MANAGER_H +#define CLOUD_DISK_SYNC_FOLDER_MANAGER_H + +#include "cloud_disk_comm.h" + +namespace OHOS { +namespace FileManagement { +class CloudDiskSyncFolderManager { +public: + CLOUD_DISK_EXPORT static CloudDiskSyncFolderManager &GetInstance(); + virtual int32_t Register(const SyncFolder rootInfo) = 0; + virtual int32_t Unregister(const std::string path) = 0; + virtual int32_t Active(const std::string path) = 0; + virtual int32_t Deactive(const std::string path) = 0; + virtual int32_t GetSyncFolders(std::vector &syncFolders) = 0; + virtual int32_t UpdateDisplayName(const std::string path, const std::string displayName) = 0; + // function for sa + virtual int32_t UnregisterForSa(const std::string path) = 0; + virtual int32_t GetAllSyncFoldersForSa(std::vector &syncFolderExts) = 0; +}; +} // namespace FileManagement +} // namespace OHOS +#endif // CLOUD_DISK_SYNC_FOLDER_MANAGER_H \ No newline at end of file diff --git a/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager_impl.h b/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager_impl.h new file mode 100644 index 00000000..ea21280a --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/include/cloud_disk_sync_folder_manager_impl.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef CLOUD_DISK_SYNC_FOLDER_MANAGER_IMPL_H +#define CLOUD_DISK_SYNC_FOLDER_MANAGER_IMPL_H + +#include "cloud_disk_sync_folder_manager.h" + +namespace OHOS { +namespace FileManagement { +class CloudDiskSyncFolderManagerImpl : public CloudDiskSyncFolderManager { +public: + static CloudDiskSyncFolderManagerImpl &GetInstance(); + virtual int32_t Register(const SyncFolder rootInfo) override; + virtual int32_t Unregister(const std::string path) override; + virtual int32_t Active(const std::string path) override; + virtual int32_t Deactive(const std::string path) override; + virtual int32_t GetSyncFolders(std::vector &syncFolders) override; + virtual int32_t UpdateDisplayName(const std::string path, const std::string displayName) override; + // function for sa + virtual int32_t UnregisterForSa(const std::string path) override; + virtual int32_t GetAllSyncFoldersForSa(std::vector &syncFolderExts) override; +}; +} // namespace FileManagement +} // namespace OHOS +#endif // CLOUD_DISK_SYNC_FOLDER_MANAGER_IMPL_H \ No newline at end of file diff --git a/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_js_manager.cpp b/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_js_manager.cpp new file mode 100644 index 00000000..10214b73 --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_js_manager.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cloud_disk_js_manager.h" + +#include "ipc_skeleton.h" +#include "tokenid_kit.h" +#include "file_access_framework_errno.h" +#include "file_access_service_client.h" + +namespace OHOS { +namespace FileManagement { +using namespace FileAccessFwk; +#ifdef SUPPORT_CLOUD_DISK_MANAGER +constexpr int MAX_RETRY_TIMES = 3; +static bool IsSystemApp() +{ + uint64_t accessTokenIDEx = OHOS::IPCSkeleton::GetCallingFullTokenID(); + return OHOS::Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(accessTokenIDEx); +} + +std::set cloudDiskJSErrCode = { + FileAccessFwk::ERR_OK, // Success + E_PERMISSION, // Permission verification failed + E_PERMISSION_SYS, // is not system app + E_IPC_FAILED, // IPC error + E_INTERNAL_ERROR, // Internal error, 14: off set, others(11-14) for dfs_cloud + E_SYSTEM_RESTRICTED, // System restricted +}; + +static int32_t ConvertErrCode(int32_t errCode) +{ + if (cloudDiskJSErrCode.find(errCode) == cloudDiskJSErrCode.end()) { + return E_IPC_FAILED; + } + return errCode; +} +#endif + +int CloudDiskJSManager::GetAllSyncFolders(std::vector &syncFolderExts) +{ + HILOG_INFO("CloudDiskJSManager::GetAllSyncFolders in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + if (!IsSystemApp()) { + HILOG_ERROR("GetAllSyncFolders check IsSystemAppByFullTokenID failed"); + return E_PERMISSION_SYS; + } + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("GetAllSyncFolders get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->GetAllSyncFolders(syncFolderExts); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("GetAllSyncFolders get SA failed"); + } else { + ret = proxy->GetAllSyncFolders(syncFolderExts); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager.cpp b/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager.cpp new file mode 100644 index 00000000..9e0625e6 --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cloud_disk_sync_folder_manager.h" +#include "cloud_disk_sync_folder_manager_impl.h" + +namespace OHOS { +namespace FileManagement { +CloudDiskSyncFolderManager &CloudDiskSyncFolderManager::GetInstance() +{ + return CloudDiskSyncFolderManagerImpl::GetInstance(); +} +} // namespace FileManagement +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager_impl.cpp b/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager_impl.cpp new file mode 100644 index 00000000..39c3c8a1 --- /dev/null +++ b/interfaces/inner_api/cloud_disk_kit_inner/src/cloud_disk_sync_folder_manager_impl.cpp @@ -0,0 +1,282 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cloud_disk_sync_folder_manager_impl.h" +#include "file_access_service_client.h" +#include "hilog_wrapper.h" + +namespace OHOS { +namespace FileManagement { +using namespace FileAccessFwk; +#ifdef SUPPORT_CLOUD_DISK_MANAGER +constexpr int MAX_RETRY_TIMES = 3; +std::set cloudDiskJSErrCode = { + FileAccessFwk::ERR_OK, // Success + E_PERMISSION, // Permission verification failed + E_PERMISSION_SYS, // is not system app + E_INVALID_PARAM, // Invalid parameter + E_SYNC_FOLDER_PATH_UNAUTHORIZED, // Sync folder unauthorized + E_IPC_FAILED, // IPC error + E_SYNC_FOLDER_LIMIT_EXCEEDED, // Sync folder limit exceeded + E_SYNC_FOLDER_CONFLICT_SELF, // Conflict with own app's Sync folder + E_SYNC_FOLDER_CONFLICT_OTHER, // Conflict with other app's Sync folder + E_REGISTER_SYNC_FOLDER_FAILED, // Failed to register Sync folder + E_SYNC_FOLDER_NOT_REGISTERED, // Sync folder not registered + E_REMOVE_SYNC_FOLDER_FAILED, // Failed to remove Sync folder + E_SYNC_FOLDER_NOT_EXIST, // Sync folder not exist + E_LISTENER_NOT_REGISTERED, // Listener not registered + E_LISTENER_ALREADY_REGISTERED, // Listener already registered + E_INVALID_CHANGE_SEQUENCE, // Invalid change sequence + E_TRY_AGAIN, // Try again + E_INTERNAL_ERROR, // Internal error + E_SYSTEM_RESTRICTED, // System restricted +}; + +int32_t ConvertErrCode(int32_t errCode) +{ + if (cloudDiskJSErrCode.find(errCode) == cloudDiskJSErrCode.end()) { + return E_IPC_FAILED; + } + return errCode; +} +#endif + +CloudDiskSyncFolderManagerImpl &CloudDiskSyncFolderManagerImpl::GetInstance() +{ + static CloudDiskSyncFolderManagerImpl instance; + return instance; +} + +int CloudDiskSyncFolderManagerImpl::Register(const SyncFolder syncFolder) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::Register in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Register get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->Register(syncFolder); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Register get SA failed"); + } else { + ret = proxy->Register(syncFolder); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int CloudDiskSyncFolderManagerImpl::Unregister(const std::string path) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::Unregister in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + if (path.empty()) { + HILOG_ERROR("Unregister path is empty"); + return E_INVALID_PARAM; + } + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Unregister get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->Unregister(path); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Register get SA failed"); + } else { + ret = proxy->Unregister(path); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int CloudDiskSyncFolderManagerImpl::Active(const std::string path) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::Active in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + if (path.empty()) { + HILOG_ERROR("Unregister path is empty"); + return E_INVALID_PARAM; + } + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Active get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->Active(path); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Active get SA failed"); + } else { + ret = proxy->Active(path); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int CloudDiskSyncFolderManagerImpl::Deactive(const std::string path) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::Deactive in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + if (path.empty()) { + HILOG_ERROR("Deactive path is empty"); + return E_INVALID_PARAM; + } + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Deactive get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->Deactive(path); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("Deactive get SA failed"); + } else { + ret = proxy->Deactive(path); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int CloudDiskSyncFolderManagerImpl::GetSyncFolders(std::vector &syncFolders) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::GetSyncFolders in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("GetSyncFolders get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->GetSyncFolders(syncFolders); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("GetSyncFolders get SA failed"); + } else { + ret = proxy->GetSyncFolders(syncFolders); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int CloudDiskSyncFolderManagerImpl::UpdateDisplayName(const std::string path, const std::string displayName) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::UpdateDisplayName in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + if (path.empty() || displayName.empty()) { + HILOG_ERROR("UpdateDisplayName path or displayName is empty"); + return E_INVALID_PARAM; + } + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("UpdateDisplayName get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->UpdateDisplayName(path, displayName); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("UpdateDisplayName get SA failed"); + } else { + ret = proxy->UpdateDisplayName(path, displayName); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int32_t CloudDiskSyncFolderManagerImpl::GetAllSyncFoldersForSa(std::vector &syncFolderExts) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::GetAllSyncFoldersForSa in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("GetAllRootsForSa get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->GetAllSyncFoldersForSa(syncFolderExts); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("GetAllRootsForSa get SA failed"); + } else { + ret = proxy->GetAllSyncFoldersForSa(syncFolderExts); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} + +int32_t CloudDiskSyncFolderManagerImpl::UnregisterForSa(const std::string path) +{ + HILOG_INFO("CloudDiskSyncFolderManagerImpl::UnregisterForSa in"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + if (path.empty()) { + HILOG_ERROR("Parameter error, path: %{public}s", path.c_str()); + return E_INVALID_PARAM; + } + auto proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("UnregisterForSa get SA failed"); + return E_INTERNAL_ERROR; + } + int ret = proxy->UnregisterForSa(path); + int retryTimes = 1; + while (ret == E_SERVICE_DIED && retryTimes <= MAX_RETRY_TIMES) { + proxy = FileAccessServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOG_ERROR("UnregisterForSa get SA failed"); + } else { + ret = proxy->UnregisterForSa(path); + } + ++retryTimes; + } + return ConvertErrCode(ret); +#endif + return E_SYSTEM_RESTRICTED; +} +} // namespace FileManagement +} // namespace OHOS \ No newline at end of file diff --git a/services/BUILD.gn b/services/BUILD.gn index b269f07e..4cf67357 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -199,6 +199,10 @@ ohos_shared_library("file_access_service") { "${user_file_service_path}/interfaces/inner_api/file_access:file_access_extension_ability_kit", ] + if (user_file_service_cloud_disk_enable) { + defines = ["SUPPORT_CLOUD_DISK_MANAGER"] + } + external_deps = [ "ability_base:want", "ability_base:zuri", diff --git a/services/IFileAccessServiceBase.idl b/services/IFileAccessServiceBase.idl index efb2813c..aeab6607 100644 --- a/services/IFileAccessServiceBase.idl +++ b/services/IFileAccessServiceBase.idl @@ -38,4 +38,6 @@ interface OHOS.FileAccessFwk.IFileAccessServiceBase { void GetSyncFolders([out] SyncFolder[] syncFolders); void GetAllSyncFolders([out] SyncFolderExt[] syncFolderExts); void UpdateDisplayName([in] String path, [in] String displayName); + void UnregisterForSa([in] String path); + void GetAllSyncFoldersForSa([out] SyncFolderExt[] syncFolderExts); } \ No newline at end of file diff --git a/services/file_access_service.cfg b/services/file_access_service.cfg index ab218fe9..490b6855 100644 --- a/services/file_access_service.cfg +++ b/services/file_access_service.cfg @@ -2,12 +2,13 @@ "services" : [{ "name" : "file_access_service", "path" : ["/system/bin/sa_main", "/system/profile/file_access_service.json"], - "uid" : "file_manager", + "uid" : "ufs", "ondemand" : true, "secon" : "u:r:file_access_service:s0", "permission" : [ "ohos.permission.FILE_ACCESS_MANAGER", - "ohos.permission.CONNECT_FILE_ACCESS_EXTENSION" + "ohos.permission.CONNECT_FILE_ACCESS_EXTENSION", + "ohos.permission.ACCESS_CLOUD_DISK_INFO" ] } ] diff --git a/services/native/cloud_disk_service/src/cloud_disk_service.cpp b/services/native/cloud_disk_service/src/cloud_disk_service.cpp index b92262ba..deaa5d86 100644 --- a/services/native/cloud_disk_service/src/cloud_disk_service.cpp +++ b/services/native/cloud_disk_service/src/cloud_disk_service.cpp @@ -24,29 +24,30 @@ void FileAccessService::IncreaseCnt(const std::string &funcName) { std::lock_guard lock(calledMutex_); ++calledCount_; - HILOG_INFO("Func name: %{public}s, count: %{public}d", funcName.c_str(), calledCount_.load()); + HILOG_INFO("Func name: %{public}s, count: %{public}d", funcName.c_str(), calledCount_); } void FileAccessService::DecreaseCnt(const std::string &funcName) { std::lock_guard lock(calledMutex_); - if (calledCount_.load() > 0) { + if (calledCount_ > 0) { --calledCount_; } else { HILOG_ERROR("Invalid calledCount."); } - HILOG_INFO("Func name: %{public}s, count: %{public}d", funcName.c_str(), calledCount_.load()); + HILOG_INFO("Func name: %{public}s, count: %{public}d", funcName.c_str(), calledCount_); } bool FileAccessService::IsCalledCountValid() { std::lock_guard lock(calledMutex_); - return calledCount_.load() > 0; + return calledCount_ > 0; } int32_t FileAccessService::Register(const SyncFolder &syncFolder) { HILOG_INFO("FileAccessService::Register begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); SyncFolderExt syncFolderExt; syncFolderExt.path_ = syncFolder.path_; @@ -56,11 +57,15 @@ int32_t FileAccessService::Register(const SyncFolder &syncFolder) } DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } int32_t FileAccessService::Unregister(const std::string &path) { HILOG_INFO("FileAccessService::Unregister begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); SyncFolderExt syncFolderExt; syncFolderExt.path_ = path; @@ -70,11 +75,15 @@ int32_t FileAccessService::Unregister(const std::string &path) } DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } int32_t FileAccessService::Active(const std::string &path) { HILOG_INFO("FileAccessService::Active begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); SyncFolderExt syncFolderExt; syncFolderExt.path_ = path; @@ -84,11 +93,15 @@ int32_t FileAccessService::Active(const std::string &path) } DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } int32_t FileAccessService::Deactive(const std::string &path) { HILOG_INFO("FileAccessService::Deactive begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); SyncFolderExt syncFolderExt; syncFolderExt.path_ = path; @@ -98,27 +111,39 @@ int32_t FileAccessService::Deactive(const std::string &path) } DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } int32_t FileAccessService::GetSyncFolders(std::vector &syncFolders) { HILOG_INFO("FileAccessService::GetSyncFolders begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } int32_t FileAccessService::GetAllSyncFolders(std::vector &syncFolderExts) { HILOG_INFO("FileAccessService::GetAllSyncFolders begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } int32_t FileAccessService::UpdateDisplayName(const std::string &path, const std::string &displayName) { HILOG_INFO("FileAccessService::UpdateDisplayName begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER IncreaseCnt(__func__); SyncFolderExt syncFolderExt; syncFolderExt.path_ = path; @@ -129,6 +154,39 @@ int32_t FileAccessService::UpdateDisplayName(const std::string &path, const std: } DecreaseCnt(__func__); return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif +} + +int32_t FileAccessService::UnregisterForSa(const string &path) +{ + HILOG_INFO("FileAccessService::UnregisterForSa begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + IncreaseCnt(__func__); + SyncFolderExt syncFolderExt; + syncFolderExt.path_ = path; + if (!NotifyWorkService::GetInstance().NotifySyncFolderEvent(syncFolderExt, + NotifyWorkService::EventType::UNREGISTER)) { + HILOG_ERROR("FileAccessService::UnregisterForSa NotifySyncFolderEvent failed"); + } + DecreaseCnt(__func__); + return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif +} + +int32_t FileAccessService::GetAllSyncFoldersForSa(std::vector &syncFolderExt) +{ + HILOG_INFO("FileAccessService::GetAllSyncFoldersForSa begin"); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + IncreaseCnt(__func__); + DecreaseCnt(__func__); + return ERR_OK; +#else + return E_SYSTEM_RESTRICTED; +#endif } } // namespace FileAccessFwk } // namespace OHOS diff --git a/services/native/file_access_service/include/file_access_service.h b/services/native/file_access_service/include/file_access_service.h index 143cc854..393d2843 100644 --- a/services/native/file_access_service/include/file_access_service.h +++ b/services/native/file_access_service/include/file_access_service.h @@ -252,6 +252,8 @@ protected: int32_t GetSyncFolders(std::vector &syncFolder) override; int32_t GetAllSyncFolders(std::vector &syncFolderExt) override; int32_t UpdateDisplayName(const std::string &path, const std::string &displayName) override; + int32_t UnregisterForSa(const string &path) override; + int32_t GetAllSyncFoldersForSa(std::vector &syncFolderExt) override; private: class ExtensionDeathRecipient : public IRemoteObject::DeathRecipient { @@ -320,7 +322,7 @@ private: std::unordered_map> appProxyMap_; std::unordered_map> appConnection_; sptr appDeathRecipient_; - std::atomic calledCount_{0}; + int calledCount_{0}; std::mutex calledMutex_; }; } // namespace FileAccessFwk diff --git a/services/native/file_access_service/src/file_access_service.cpp b/services/native/file_access_service/src/file_access_service.cpp index 49b311e2..b4a8158e 100644 --- a/services/native/file_access_service/src/file_access_service.cpp +++ b/services/native/file_access_service/src/file_access_service.cpp @@ -684,7 +684,7 @@ int32_t FileAccessService::OnChange(const Uri &uri, NotifyType notifyType) bool FileAccessService::IsUnused() { HILOG_INFO("IsUnused: obsManager_: %{public}d, appProxyMap_: %{public}d, calledCount_: %{public}d", - obsManager_.isEmpty(), appProxyMap_.empty(), calledCount_.load()); + obsManager_.isEmpty(), appProxyMap_.empty(), calledCount_); return obsManager_.isEmpty() && appProxyMap_.empty() && !IsCalledCountValid(); } diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 64ddccaf..0b9870bb 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -373,6 +373,134 @@ ohos_unittest("urie_test") { defines = [ "private=public" ] } +ohos_unittest("cloud_disk_js_manager_test") { + branch_protector_ret = "pac_ret" + sanitize = { + integer_overflow = true + cfi = true + cfi_cross_dso = true + debug = false + blocklist = "${user_file_service_path}/cfi_blocklist.txt" + } + module_out_path = "user_file_service/user_file_service" + + include_dirs = [ + "${user_file_service_path}/interfaces/inner_api/cloud_disk_kit_inner/include", + "${user_file_service_path}/interfaces/inner_api/file_access/include", + "${user_file_service_path}/interfaces/inner_api/file_access/src", + "${user_file_service_path}/interfaces/kits/js/src/common", + "${user_file_service_path}/services/native/file_access_service/include", + "${user_file_service_path}/utils", + "mock", + ] + + sources = [ + "cloud_disk_js_manager_test.cpp", + ] + + deps = [ + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_ext_base_include", + "${user_file_service_path}/interfaces/inner_api/cloud_disk_kit_inner:cloud_disk_manager_js_kit", + "${user_file_service_path}/services:file_access_service_base_include", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:app_context", + "ability_runtime:extensionkit_native", + "ability_runtime:napi_common", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "file_api:filemgmt_libn", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "hitrace:hitrace_meter", + "init:libbegetutil", + "ipc:ipc_core", + "ipc:ipc_napi", + "napi:ace_napi", + "os_account:os_account_innerkits", + "safwk:system_ability_fwk", + "samgr:samgr_proxy" + ] + + defines = [ "private=public" ] + + if (user_file_service_cloud_disk_enable) { + defines += ["SUPPORT_CLOUD_DISK_MANAGER"] + } + + use_exceptions = true +} + +ohos_unittest("cloud_disk_sync_folder_manager_test") { + branch_protector_ret = "pac_ret" + sanitize = { + integer_overflow = true + cfi = true + cfi_cross_dso = true + debug = false + blocklist = "${user_file_service_path}/cfi_blocklist.txt" + } + module_out_path = "user_file_service/user_file_service" + + include_dirs = [ + "${user_file_service_path}/interfaces/inner_api/cloud_disk_kit_inner/include", + "${user_file_service_path}/interfaces/inner_api/file_access/include", + "${user_file_service_path}/interfaces/inner_api/file_access/src", + "${user_file_service_path}/interfaces/kits/js/src/common", + "${user_file_service_path}/services/native/file_access_service/include", + "${user_file_service_path}/utils", + "mock", + ] + + sources = [ + "cloud_disk_sync_folder_manager_test.cpp", + ] + + deps = [ + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_ext_base_include", + "${user_file_service_path}/interfaces/inner_api/cloud_disk_kit_inner:cloud_disk_manager_kit", + "${user_file_service_path}/services:file_access_service_base_include", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:app_context", + "ability_runtime:extensionkit_native", + "ability_runtime:napi_common", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "file_api:filemgmt_libn", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "hitrace:hitrace_meter", + "init:libbegetutil", + "ipc:ipc_core", + "ipc:ipc_napi", + "napi:ace_napi", + "os_account:os_account_innerkits", + "safwk:system_ability_fwk", + "samgr:samgr_proxy" + ] + + defines = [ "private=public" ] + + if (user_file_service_cloud_disk_enable) { + defines += ["SUPPORT_CLOUD_DISK_MANAGER"] + } + + use_exceptions = true +} + ohos_unittest("cloud_disk_service_test") { branch_protector_ret = "pac_ret" sanitize = { @@ -432,6 +560,10 @@ ohos_unittest("cloud_disk_service_test") { "protected=public" ] + if (user_file_service_cloud_disk_enable) { + defines += ["SUPPORT_CLOUD_DISK_MANAGER"] + } + use_exceptions = true } @@ -532,7 +664,9 @@ group("user_file_service_unit_test") { deps = [ ":abnormal_file_access_test", + ":cloud_disk_js_manager_test", ":cloud_disk_service_test", + ":cloud_disk_sync_folder_manager_test", ":external_file_access_basic_test", ":external_file_access_management_test", ":external_file_access_notify_test", diff --git a/test/unittest/cloud_disk_js_manager_test.cpp b/test/unittest/cloud_disk_js_manager_test.cpp new file mode 100644 index 00000000..fe929845 --- /dev/null +++ b/test/unittest/cloud_disk_js_manager_test.cpp @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "cloud_disk_js_manager.h" +#include "file_access_framework_errno.h" +#include "file_access_service_client.h" + +using namespace testing; +using namespace testing::ext; + +using namespace OHOS; +using namespace FileAccessFwk; + +namespace OHOS { +namespace FileManagement { +class CloudDiskJSManagerTest : public testing::Test { +public: + static void SetUpTestCase(void) + { + } + static void TearDownTestCase() + { + } + void SetUp() + { + } + void TearDown() + { + } +}; + +/** + * @tc.number: user_file_service_cloud_disk_js_manager_GetAllSyncFolders_001 + * @tc.name: GetAllSyncFolders + * @tc.desc: Test GetAllSyncFolders interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskJSManagerTest, CloudDiskJSManager_GetAllSyncFolders_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskJSManager_GetAllSyncFolders_001 start"; + std::vector syncFolderExts; + CloudDiskJSManager cloudDiskJSManager; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + auto res = cloudDiskJSManager.GetAllSyncFolders(syncFolderExts); + EXPECT_EQ(res, E_PERMISSION_SYS); +#else + auto res = cloudDiskJSManager.GetAllSyncFolders(syncFolderExts); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskJSManager_GetAllSyncFolders_001 end"; +} +} // namespace FileManagement +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/cloud_disk_service_test.cpp b/test/unittest/cloud_disk_service_test.cpp index 74531256..b4927472 100644 --- a/test/unittest/cloud_disk_service_test.cpp +++ b/test/unittest/cloud_disk_service_test.cpp @@ -68,7 +68,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_Register_001, TestSize.Level1) sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->Register(syncFolder); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_Register_001"; } @@ -84,7 +88,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_Unregister_001, TestSize.Level1) sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->Unregister(path); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_Unregister_001"; } @@ -101,7 +109,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_Active_001, TestSize.Level1) sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->Active(path); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_Active_001"; } @@ -118,7 +130,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_InActive_001, TestSize.Level1) sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->Deactive(path); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_InActive_001"; } @@ -135,7 +151,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_GetSyncFolders_001, TestSize.Lev sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->GetSyncFolders(syncFolders); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_GetSyncFolders_001"; } @@ -152,7 +172,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_GetAllSyncFolders_001, TestSize. sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->GetAllSyncFolders(syncFolderExts); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_GetAllSyncFolders_001"; } @@ -170,7 +194,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_UpdateDisplayName_001, TestSize. sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); int32_t result = service->UpdateDisplayName(path, displayName); +#ifdef SUPPORT_CLOUD_DISK_MANAGER EXPECT_EQ(result, ERR_OK); +#else + EXPECT_EQ(result, E_SYSTEM_RESTRICTED); +#endif GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_UpdateDisplayName_001"; } @@ -185,9 +213,9 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_IncreaseCnt_001, TestSize.Level1 sptr service = FileAccessService::GetInstance(); ASSERT_NE(service, nullptr); - int32_t initialCount = service->calledCount_.load(); + int32_t initialCount = service->calledCount_; service->IncreaseCnt("test_func"); - EXPECT_EQ(service->calledCount_.load(), initialCount + 1); + EXPECT_EQ(service->calledCount_, initialCount + 1); GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_IncreaseCnt_001"; } @@ -203,9 +231,9 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_DecreaseCnt_001, TestSize.Level1 ASSERT_NE(service, nullptr); service->IncreaseCnt("test_func"); // Make sure count > 0 - int32_t initialCount = service->calledCount_.load(); + int32_t initialCount = service->calledCount_; service->DecreaseCnt("test_func"); - EXPECT_EQ(service->calledCount_.load(), initialCount - 1); + EXPECT_EQ(service->calledCount_, initialCount - 1); GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_DecreaseCnt_001"; } @@ -221,11 +249,11 @@ HWTEST_F(CloudDiskServiceTest, CloudDiskService_DecreaseCnt_002, TestSize.Level1 ASSERT_NE(service, nullptr); // Ensure count is 0 - service->calledCount_.store(0); + service->calledCount_ = 0; - int32_t initialCount = service->calledCount_.load(); + int32_t initialCount = service->calledCount_; service->DecreaseCnt("test_func"); - EXPECT_EQ(service->calledCount_.load(), initialCount); // Should remain 0 + EXPECT_EQ(service->calledCount_, initialCount); // Should remain 0 GTEST_LOG_(INFO) << "CloudDiskServiceTest-end CloudDiskService_DecreaseCnt_002"; } } // namespace FileAccessFwk diff --git a/test/unittest/cloud_disk_sync_folder_manager_test.cpp b/test/unittest/cloud_disk_sync_folder_manager_test.cpp new file mode 100644 index 00000000..dd14796c --- /dev/null +++ b/test/unittest/cloud_disk_sync_folder_manager_test.cpp @@ -0,0 +1,668 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "cloud_disk_sync_folder_manager.h" +#include "file_access_framework_errno.h" +#include "file_access_service_client.h" +#include "file_access_service_mock.h" + +using namespace testing; +using namespace testing::ext; + +using namespace OHOS; +using namespace FileAccessFwk; + +namespace { + sptr g_fileAccessSvc = nullptr; + bool g_svcTrue = false; +} + +sptr FileAccessServiceClient::GetInstance() +{ + if (g_svcTrue) { + return iface_cast(g_fileAccessSvc); + } else { + return nullptr; + } +} + +namespace OHOS { +namespace FileManagement { +class CloudDiskSyncFolderManagerTest : public testing::Test { +public: + static void SetUpTestCase(void) + { + } + static void TearDownTestCase() + { + } + void SetUp() + { + g_fileAccessSvc = new (std::nothrow) FileAccessServiceMock(); + ASSERT_NE(g_fileAccessSvc, nullptr); + } + void TearDown() + { + g_fileAccessSvc = nullptr; + } +}; + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Register_001 + * @tc.name: Register + * @tc.desc: Test Register interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Register_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Register_001 start"; + SyncFolder syncFolder; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + g_svcTrue = false; + auto res = cloudDiskSyncFolderManager.Register(syncFolder); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + auto res = cloudDiskSyncFolderManager.Register(syncFolder); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Register_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Register_002 + * @tc.name: Register + * @tc.desc: Test Register interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Register_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Register_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + SyncFolder syncFolder; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Register(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Register(syncFolder); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Register_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Register_003 + * @tc.name: Register + * @tc.desc: Test Register interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Register_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Register_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + SyncFolder syncFolder; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Register(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Register(syncFolder); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Register_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Unregister_001 + * @tc.name: Unregister + * @tc.desc: Test Unregister interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Unregister_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Unregister_001 start"; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = ""; + auto res = cloudDiskSyncFolderManager.Unregister(uri); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = "test_uri"; + g_svcTrue = false; + res = cloudDiskSyncFolderManager.Unregister(uri); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + std::string uri = "test_uri"; + auto res = cloudDiskSyncFolderManager.Unregister(uri); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Unregister_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Unregister_002 + * @tc.name: Unregister + * @tc.desc: Test Unregister interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Unregister_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Unregister_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Unregister(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Unregister(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Unregister_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Unregister_003 + * @tc.name: Unregister + * @tc.desc: Test Unregister interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Unregister_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Unregister_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Unregister(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Unregister(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Unregister_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Active_001 + * @tc.name: Active + * @tc.desc: Test Active interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Active_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Active_001 start"; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = ""; + auto res = cloudDiskSyncFolderManager.Active(uri); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = "test_uri"; + g_svcTrue = false; + res = cloudDiskSyncFolderManager.Active(uri); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + std::string uri = "test_uri"; + auto res = cloudDiskSyncFolderManager.Active(uri); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Active_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Active_002 + * @tc.name: Active + * @tc.desc: Test Active interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Active_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Active_002 start"; + +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Active(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Active(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Active_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_Active_003 + * @tc.name: Active + * @tc.desc: Test Active interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_Active_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Active_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Active(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Active(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_Active_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_InActive_001 + * @tc.name: Deactive + * @tc.desc: Test Deactive interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_InActive_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_InActive_001 start"; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = ""; + g_svcTrue = false; + auto res = cloudDiskSyncFolderManager.Deactive(uri); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = "test_uri"; + res = cloudDiskSyncFolderManager.Deactive(uri); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + std::string uri = "test_uri"; + auto res = cloudDiskSyncFolderManager.Deactive(uri); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_InActive_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_InActive_002 + * @tc.name: Deactive + * @tc.desc: Test Deactive interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_InActive_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_InActive_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Deactive(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Deactive(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_InActive_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_InActive_003 + * @tc.name: Deactive + * @tc.desc: Test Deactive interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_InActive_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_InActive_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, Deactive(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.Deactive(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_InActive_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_GetSyncFolders_001 + * @tc.name: GetSyncFolders + * @tc.desc: Test GetSyncFolders interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_GetSyncFolders_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetSyncFolders_001 start"; + std::vector syncFolders; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + g_svcTrue = false; + auto res = cloudDiskSyncFolderManager.GetSyncFolders(syncFolders); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + auto res = cloudDiskSyncFolderManager.GetSyncFolders(syncFolders); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetSyncFolders_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_GetSyncFolders_002 + * @tc.name: GetSyncFolders + * @tc.desc: Test GetSyncFolders interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_GetSyncFolders_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetSyncFolders_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::vector syncFolders; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, GetSyncFolders(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.GetSyncFolders(syncFolders); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetSyncFolders_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_GetSyncFolders_003 + * @tc.name: GetSyncFolders + * @tc.desc: Test GetSyncFolders interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_GetSyncFolders_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetSyncFolders_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::vector syncFolders; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, GetSyncFolders(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.GetSyncFolders(syncFolders); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetSyncFolders_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_UpdateDisplayName_001 + * @tc.name: UpdateDisplayName + * @tc.desc: Test UpdateDisplayName interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_UpdateDisplayName_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UpdateDisplayName_001 start"; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = ""; + std::string displayName = "test_display_name"; + g_svcTrue = false; + auto res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = "test_uri"; + displayName = ""; + res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = ""; + displayName = ""; + res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = "test_uri"; + displayName = "test_display_name"; + res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + std::string uri = "test_uri"; + std::string displayName = "test_display_name"; + auto res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UpdateDisplayName_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_UpdateDisplayName_002 + * @tc.name: UpdateDisplayName + * @tc.desc: Test UpdateDisplayName interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_UpdateDisplayName_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UpdateDisplayName_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + std::string displayName = "test_display_name"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, UpdateDisplayName(_, _)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UpdateDisplayName_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_UpdateDisplayName_003 + * @tc.name: UpdateDisplayName + * @tc.desc: Test UpdateDisplayName interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_UpdateDisplayName_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UpdateDisplayName_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + std::string displayName = "test_display_name"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, UpdateDisplayName(_, _)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.UpdateDisplayName(uri, displayName); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UpdateDisplayName_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_UnregisterForSa_001 + * @tc.name: UnregisterForSa + * @tc.desc: Test UnregisterForSa interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_UnregisterForSa_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UnregisterForSa_001 start"; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = ""; + g_svcTrue = false; + auto res = cloudDiskSyncFolderManager.UnregisterForSa(uri); + EXPECT_EQ(res, E_INVALID_PARAM); + + uri = "test_uri"; + res = cloudDiskSyncFolderManager.UnregisterForSa(uri); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + std::string uri = "test_uri"; + auto res = cloudDiskSyncFolderManager.UnregisterForSa(uri); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UnregisterForSa_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_UnregisterForSa_002 + * @tc.name: UnregisterForSa + * @tc.desc: Test UnregisterForSa interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_UnregisterForSa_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UnregisterForSa_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, UnregisterForSa(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.UnregisterForSa(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UnregisterForSa_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_UnregisterForSa_003 + * @tc.name: UnregisterForSa + * @tc.desc: Test UnregisterForSa interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_UnregisterForSa_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UnregisterForSa_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::string uri = "test_uri"; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, UnregisterForSa(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.UnregisterForSa(uri); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_UnregisterForSa_003 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_GetAllSyncFoldersForSa_001 + * @tc.name: GetAllSyncFoldersForSa + * @tc.desc: Test GetAllSyncFoldersForSa interface for failure case with null proxy. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_001 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::vector syncFolderExts; + g_svcTrue = false; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.GetAllSyncFoldersForSa(syncFolderExts); + EXPECT_EQ(res, E_INTERNAL_ERROR); +#else + std::vector syncFolderExts; + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.GetAllSyncFoldersForSa(syncFolderExts); + EXPECT_EQ(res, E_SYSTEM_RESTRICTED); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_001 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_GetAllSyncFoldersForSa_002 + * @tc.name: GetAllSyncFoldersForSa + * @tc.desc: Test GetAllSyncFoldersForSa interface for success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_002 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::vector syncFolderExts; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, GetAllSyncFoldersForSa(_)).WillOnce(Return(0)); + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.GetAllSyncFoldersForSa(syncFolderExts); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_002 end"; +} + +/** + * @tc.number: user_file_service_cloud_disk_sync_folder_manager_GetAllSyncFoldersForSa_003 + * @tc.name: GetAllSyncFoldersForSa + * @tc.desc: Test GetAllSyncFoldersForSa interface for service died and retry success case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(CloudDiskSyncFolderManagerTest, CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_003 start"; +#ifdef SUPPORT_CLOUD_DISK_MANAGER + std::vector syncFolderExts; + g_svcTrue = true; + EXPECT_CALL(*g_fileAccessSvc, GetAllSyncFoldersForSa(_)) + .WillOnce(Return(E_SERVICE_DIED)) // E_SERVICE_DIED + .WillOnce(Return(0)); // Success on retry + CloudDiskSyncFolderManager &cloudDiskSyncFolderManager = CloudDiskSyncFolderManager::GetInstance(); + auto res = cloudDiskSyncFolderManager.GetAllSyncFoldersForSa(syncFolderExts); + EXPECT_EQ(res, 0); +#endif + GTEST_LOG_(INFO) << "CloudDiskSyncFolderManager_GetAllSyncFoldersForSa_003 end"; +} +} // namespace FileManagement +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/js_file_access_ext_ability_test.cpp b/test/unittest/js_file_access_ext_ability_test.cpp index c1ed6dd7..3a79b379 100644 --- a/test/unittest/js_file_access_ext_ability_test.cpp +++ b/test/unittest/js_file_access_ext_ability_test.cpp @@ -117,6 +117,16 @@ int32_t FileAccessServiceBaseProxy::UpdateDisplayName(const std::string &path, c return ERR_OK; } +int32_t FileAccessServiceBaseProxy::UnregisterForSa(const string &path) +{ + return ERR_OK; +} + +int32_t FileAccessServiceBaseProxy::GetAllSyncFoldersForSa(std::vector &syncFolderExts) +{ + return ERR_OK; +} + void FileAccessExtAbility::Init(const std::shared_ptr &record, const std::shared_ptr &application, std::shared_ptr &handler, diff --git a/test/unittest/mock/file_access_service_mock.h b/test/unittest/mock/file_access_service_mock.h index 3f27b1bb..d2ca0126 100644 --- a/test/unittest/mock/file_access_service_mock.h +++ b/test/unittest/mock/file_access_service_mock.h @@ -49,6 +49,8 @@ public: MOCK_METHOD1(GetSyncFolders, int32_t(std::vector &syncFolders)); MOCK_METHOD1(GetAllSyncFolders, int32_t(std::vector &syncFolderExts)); MOCK_METHOD2(UpdateDisplayName, int32_t(const std::string &path, const std::string &displayName)); + MOCK_METHOD1(UnregisterForSa, int32_t(const std::string &path)); + MOCK_METHOD1(GetAllSyncFoldersForSa, int32_t(std::vector &syncFolderExts)); }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/utils/file_access_framework_errno.h b/utils/file_access_framework_errno.h index 7eedadb2..50e77878 100644 --- a/utils/file_access_framework_errno.h +++ b/utils/file_access_framework_errno.h @@ -28,7 +28,7 @@ const int ERR_URI = 13900002; const int ERR_NOT_DIR = 13900018; const int ERR_IS_DIR = 13900019; const int BASE_OFFSET = 14300001; -const int CLOUD_DISK_BASE_OFFSET = 34400001; +const int CLOUD_DISK_ERR_OFFSET = 34400001; enum { ERR_OK = 0, E_IPCS = BASE_OFFSET, // IPC error @@ -49,22 +49,24 @@ enum { E_PERMISSION = 201, // Permission verification failed E_PERMISSION_SYS, // is not system app - E_NOT_SUPPORT = 801, - E_SERVICE_DIED = 29189, + E_SERVICE_DIED = 29189, // Service died // cloud disk errcode - E_INVALID_PARAM = CLOUD_DISK_BASE_OFFSET, // Invalid parameter - E_PERSIST_SYNC_FOLDER_FAILED, // Failed to persist Sync folder + E_INVALID_PARAM = 34400001, // Invalid parameter + E_SYNC_FOLDER_PATH_UNAUTHORIZED, // Sync folder unauthorized E_IPC_FAILED, // IPC error E_SYNC_FOLDER_LIMIT_EXCEEDED, // Sync folder limit exceeded E_SYNC_FOLDER_CONFLICT_SELF, // Conflict with own app's Sync folder E_SYNC_FOLDER_CONFLICT_OTHER, // Conflict with other app's Sync folder - E_CREATE_SYNC_FOLDER_FAILED, // Failed to create Sync folder + E_REGISTER_SYNC_FOLDER_FAILED, // Failed to register Sync folder E_SYNC_FOLDER_NOT_REGISTERED, // Sync folder not registered E_REMOVE_SYNC_FOLDER_FAILED, // Failed to remove Sync folder - E_UPDATE_SYNC_FOLDER_FAILED, // Failed to update Sync folder properties E_SYNC_FOLDER_NOT_EXIST, // Sync folder not exist - E_INTERNAL_ERROR = CLOUD_DISK_BASE_OFFSET + 15, // Internal error 15: offset + E_LISTENER_NOT_REGISTERED, // Listener not registered + E_LISTENER_ALREADY_REGISTERED, // Listener already registered + E_INVALID_CHANGE_SEQUENCE, // Invalid change sequence + E_TRY_AGAIN, // Try again + E_INTERNAL_ERROR, // Internal error E_SYSTEM_RESTRICTED, // System restricted }; } // namespace FileAccessFwk -- Gitee