diff --git a/frameworks/native/cloud_file_kit_inner/src/data_sync/data_syncer_rdb_store.cpp b/frameworks/native/cloud_file_kit_inner/src/data_sync/data_syncer_rdb_store.cpp index 0182ea66bf3f4dd30d24e5394ddf8103dd97f0c1..89825c16fd2c1ed7e30813dfa9244fdc7b674d9f 100644 --- a/frameworks/native/cloud_file_kit_inner/src/data_sync/data_syncer_rdb_store.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/data_sync/data_syncer_rdb_store.cpp @@ -94,6 +94,35 @@ int32_t DataSyncerRdbStore::Insert(int32_t userId, const std::string &bundleName return E_OK; } +int32_t DataSyncerRdbStore::Delete(int32_t userId, const std::string &bundleName) +{ + LOGI("datasyncer delete userId: %d, bundleName: %s", userId, bundleName.c_str()); + string uniqueId = to_string(userId) + bundleName; + NativeRdb::AbsRdbPredicates predicates = NativeRdb::AbsRdbPredicates(DATA_SYNCER_TABLE); + predicates.EqualTo(DATA_SYNCER_UNIQUE_ID, uniqueId); + std::shared_ptr resultSet = nullptr; + int32_t ret = Query(predicates, resultSet); + if (ret != E_OK) { + LOGW("query dataSyncer failed, ret: %{public}d", ret); + return ret; + } + if (resultSet->GoToNextRow() != E_OK) { + LOGI("dataSyncer rdb no uniqueId: %{public}s", uniqueId.c_str()); + return E_OK; + } + { + std::lock_guard lck(rdbMutex_); + int32_t rows = -1; + ret = rdb_->Delete(rows, predicates); + } + if (ret != E_OK) { + LOGE("fail to delete, ret: %{public}d", ret); + return E_RDB; + } + + return E_OK; +} + static int64_t UTCTimeMilliSeconds() { struct timespec t; diff --git a/frameworks/native/cloud_file_kit_inner/src/data_sync/sync_state_manager.cpp b/frameworks/native/cloud_file_kit_inner/src/data_sync/sync_state_manager.cpp index e46f1b33b04c2575656cfbe32314914001c5b7a1..e0ca232aafa2a0b865d2ac3ab164020dc540b0f9 100644 --- a/frameworks/native/cloud_file_kit_inner/src/data_sync/sync_state_manager.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/data_sync/sync_state_manager.cpp @@ -32,6 +32,7 @@ Action SyncStateManager::UpdateSyncState(SyncState newState) bool SyncStateManager::CheckAndSetPending(bool forceFlag, SyncTriggerType triggerType) { + LOGD("state: %{public}d", state_); std::unique_lock lck(syncMutex_); if (!CheckCleaningFlag() && !CheckDisableCloudFlag() && @@ -58,9 +59,27 @@ bool SyncStateManager::CheckAndSetPending(bool forceFlag, SyncTriggerType trigge bool SyncStateManager::CheckMediaLibCleaning() { - auto ret = system::GetParameter(CLOUDSYNC_STATUS_KEY, ""); - LOGI("CLOUDSYNC_STATUS_KEY %{public}s", ret.c_str()); - return ret == CLOUDSYNC_STATUS_CLEANING; + std::string closeSwitchTime = system::GetParameter(CLOUDSYNC_SWITCH_STATUS, ""); + if (closeSwitchTime.empty() || closeSwitchTime == "0") { + LOGI("current no clean task"); + return false; + } + if (closeSwitchTime.size() > MICROSECOND_TIME_LENGTH_LIMIT || + !std::all_of(closeSwitchTime.begin(), closeSwitchTime.end(), ::isdigit)) { + LOGW("prev closeSwitch is invalid, reset to 0"); + system::SetParameter(CLOUDSYNC_SWITCH_STATUS, "0"); + return false; + } + + uint64_t prevTime = std::stoull(closeSwitchTime); + uint64_t curTime = GetCurrentTimeStamp(); + uint64_t intervalTime = curTime - prevTime; + if (prevTime > curTime || intervalTime >= TWELVE_HOURS_MICROSECOND) { + LOGW("prev closeSwitch over 12h, reset to 0"); + system::SetParameter(CLOUDSYNC_SWITCH_STATUS, "0"); + return false; + } + return true; } bool SyncStateManager::CheckCleaningFlag() diff --git a/frameworks/native/cloud_file_kit_inner/src/sync_rule/cloud_status.cpp b/frameworks/native/cloud_file_kit_inner/src/sync_rule/cloud_status.cpp index ac9400908d40fc0357433cb769183caade3c724c..1226a50bfc498dc01b2c490ebb2b7e3379d7a4b0 100644 --- a/frameworks/native/cloud_file_kit_inner/src/sync_rule/cloud_status.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/sync_rule/cloud_status.cpp @@ -18,6 +18,7 @@ #include "cloud_file_kit.h" #include "dfs_error.h" #include "utils_log.h" +#include "settings_data_manager.h" namespace OHOS::FileManagement::CloudSync { int32_t CloudStatus::GetCurrentCloudInfo(const std::string &bundleName, const int32_t userId) @@ -28,15 +29,24 @@ int32_t CloudStatus::GetCurrentCloudInfo(const std::string &bundleName, const in return E_NULLPTR; } - auto ret = instance->GetCloudUserInfo(userId, userInfo_); + int32_t ret = instance->GetCloudUserInfo(userId, userInfo_); if (ret != E_OK) { + LOGE("GetCloudUserInfo failed"); return ret; } bool switchStatus = false; - ret = instance->GetAppSwitchStatus(bundleName, userId, switchStatus); - if (ret != E_OK) { - return ret; + SwitchStatus curSwitch = SettingsDataManager::GetSwitchStatusByCache(); + if (bundleName == HDC_BUNDLE_NAME) { + switchStatus = curSwitch == SwitchStatus::AI_FAMILY; + } else if (bundleName == GALLERY_BUNDLE_NAME) { + switchStatus = curSwitch == SwitchStatus::CLOUD_SPACE; + } else { + ret = instance->GetAppSwitchStatus(bundleName, userId, switchStatus); + if (ret != E_OK) { + LOGE("GetAppSwitchStatus failed"); + return ret; + } } /* insert key-value */ appSwitches_.insert(std::make_pair(bundleName, switchStatus)); @@ -61,14 +71,14 @@ bool CloudStatus::IsCloudStatusOkay(const std::string &bundleName, const int32_t /* Obtain cloud information only during first sync */ auto iter = appSwitches_.find(bundleName); if (iter == appSwitches_.end()) { - LOGI("appSwitches unknown, bundleName:%{private}s, userId:%{public}d", bundleName.c_str(), userId); - auto ret = GetCurrentCloudInfo(bundleName, userId); - if (ret) { + LOGI("appSwitches unknown, bundleName: %{private}s, userId: %{public}d", bundleName.c_str(), userId); + int32_t ret = GetCurrentCloudInfo(bundleName, userId); + if (ret != E_OK) { return false; } } - LOGI("bundleName:%{private}s, cloudSatus:%{public}d, switcheStatus:%{public}d", bundleName.c_str(), + LOGI("bundleName: %{private}s, cloudSatus: %{public}d, switcheStatus: %{public}d", bundleName.c_str(), userInfo_.enableCloud, appSwitches_[bundleName]); return appSwitches_[bundleName]; } diff --git a/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_set_manager.cpp b/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_set_manager.cpp index ea8cab91ddec32888bc176d07efa86da0e1d0415..409f972defa4619efd754e1e5e6870ea96191268 100644 --- a/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_set_manager.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_set_manager.cpp @@ -26,6 +26,7 @@ #include "parameters.h" #include "system_ability_definition.h" #include "utils_log.h" +#include "settings_data_manager.h" namespace OHOS::FileManagement::CloudSync { const std::string QUERY_URI = "datashareproxy://"; @@ -174,8 +175,8 @@ bool NetworkSetManager::GetConfigParams(const std::string &bundleName, int32_t u } std::string networkDataStr = param["useMobileNetworkData"]; bool isValid = std::all_of(networkDataStr.begin(), networkDataStr.end(), ::isdigit); - if (!isValid) { - LOGE("invalid param"); + if (networkDataStr.empty() || !isValid) { + LOGE("invalid param: %{public}s", networkDataStr.c_str()); return false; } int32_t networkData = std::stoi(networkDataStr); @@ -280,14 +281,17 @@ bool NetworkSetManager::IsAllowNetConnect(const std::string &bundleName, const i void NetworkSetManager::InitNetworkSetManager(const std::string &bundleName, const int32_t userId) { LOGI("InitNetworkSetManager bundleName: %{public}s", bundleName.c_str()); - if (bundleName != PHOTOS_BUNDLE_NAME) { + if (bundleName == GALLERY_BUNDLE_NAME) { + RegisterObserver(bundleName, userId, CELLULARCONNECT); + RegisterObserver(bundleName, userId, NETCONNECT); + GetCellularConnect(bundleName, userId); + GetNetConnect(bundleName, userId); + } else if (bundleName == HDC_BUNDLE_NAME) { + SettingsDataManager::GetNetworkConnectionStatus(); + SettingsDataManager::GetMobileDataStatus(); + } else { LOGE("InitNetworkSetManager bundleName is illegals"); - return; } - RegisterObserver(bundleName, userId, CELLULARCONNECT); - RegisterObserver(bundleName, userId, NETCONNECT); - GetCellularConnect(bundleName, userId); - GetNetConnect(bundleName, userId); } void NetworkSetManager::InitDataSyncManager(std::shared_ptr dataSyncManager) diff --git a/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_status.cpp b/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_status.cpp index 4deac6742b57d6460d53971c2dd6b52811a93b31..ee8e06f7b2c667d385039da236d4f4625e8de70a 100644 --- a/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_status.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_status.cpp @@ -25,6 +25,7 @@ #include "network_set_manager.h" #include "net_conn_callback_observer.h" #include "utils_log.h" +#include "settings_data_manager.h" using namespace OHOS::NetManagerStandard; @@ -135,26 +136,35 @@ NetworkStatus::NetConnStatus NetworkStatus::GetNetConnStatus() bool NetworkStatus::CheckMobileNetwork(const std::string &bundleName, const int32_t userId) { - if (bundleName != "com.ohos.photos") { - return true; - } - if (NetworkSetManager::IsAllowCellularConnect(bundleName, userId)) { - LOGI("datashare status open, CheckMobileNetwork success"); - return true; - } - if (CheckWifiOrEthernet()) { + if (bundleName == GALLERY_BUNDLE_NAME) { + if (NetworkSetManager::IsAllowCellularConnect(bundleName, userId)) { + LOGI("datashare status open, CheckMobileNetwork success"); + return true; + } + } else if (bundleName == HDC_BUNDLE_NAME) { + if (SettingsDataManager::GetMobileDataStatus() == "on") { + LOGI("ailife is setting mobie data sync"); + return true; + } + } else { return true; } - return false; + return CheckWifiOrEthernet(); } bool NetworkStatus::CheckNetwork(const std::string &bundleName, const int32_t userId) { - if (bundleName != "com.ohos.photos") { - return true; - } - if (NetworkSetManager::IsAllowNetConnect(bundleName, userId)) { - LOGI("CheckNetwork on"); + if (bundleName == GALLERY_BUNDLE_NAME) { + if (NetworkSetManager::IsAllowNetConnect(bundleName, userId)) { + LOGI("CheckNetwork on"); + return true; + } + } else if (bundleName == HDC_BUNDLE_NAME) { + if (SettingsDataManager::GetNetworkConnectionStatus() == "on") { + LOGI("ailife is setting network connection status"); + return true; + } + } else { return true; } LOGI("CheckNetwork off"); @@ -171,6 +181,7 @@ bool NetworkStatus::CheckWifiOrEthernet() LOGI("datashare status close, network_status:ethernet"); return true; } + LOGI("CheckWifiOrEthernet off"); return false; } } // namespace OHOS::FileManagement::CloudSync \ No newline at end of file diff --git a/frameworks/native/cloud_file_kit_inner/src/sync_rule/settings_data_manager.cpp b/frameworks/native/cloud_file_kit_inner/src/sync_rule/settings_data_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2530dae13c2c89650e6c715ca0a36a6f7b342718 --- /dev/null +++ b/frameworks/native/cloud_file_kit_inner/src/sync_rule/settings_data_manager.cpp @@ -0,0 +1,308 @@ +/* + * 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 "settings_data_manager.h" + +#include "datashare_helper.h" +#include "datashare_errno.h" +#include "datashare_result_set.h" +#include "dfs_error.h" +#include "utils_log.h" + +namespace OHOS::FileManagement::CloudSync { +static const std::string SETTING_DATA_QUERY_URI = "datashareproxy://"; +static const std::string SETTING_DATA_COMMON_URI = + "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true"; +static const std::string SYNC_SWITCH_KEY = "photos_sync_options"; +static const std::string NETWORK_CONNECTION_KEY = "photos_network_connection_status"; +static const std::string LOCAL_SPACE_FREE_KEY = "photos_local_space_free"; +static const std::string LOCAL_SPACE_DAYS_KEY = "photos_local_space_days"; +static const std::string MOBILE_DATA_SYNC_KEY = "photos_mobile_data_sync"; +static const std::string AI_FAMILY_STATUS = "2"; +static const std::string CLOUD_STATUS = "1"; +static const std::string SUCCESS_STATUS = "on"; + +void SettingsDataManager::InitSettingsDataManager() +{ + LOGI("InitSettingsDataManager"); + RegisterObserver(SYNC_SWITCH_KEY); + RegisterObserver(NETWORK_CONNECTION_KEY); + RegisterObserver(MOBILE_DATA_SYNC_KEY); + QuerySwitchStatus(); + QueryNetworkConnectionStatus(); + QueryLocalSpaceFreeStatus(); + QueryLocalSpaceFreeDays(); + QueryMobileDataStatus(); +} + +int32_t SettingsDataManager::QuerySwitchStatus() +{ + std::string value; + int32_t ret = QueryParamInSettingsData(SYNC_SWITCH_KEY, value); + if (ret != E_OK) { + LOGE("query SYNC_SWITCH_KEY failed"); + settingsDataMap_.Erase(SYNC_SWITCH_KEY); + return ret; + } + settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, value); + return E_OK; +} + +int32_t SettingsDataManager::QueryNetworkConnectionStatus() +{ + std::string value; + int32_t ret = QueryParamInSettingsData(NETWORK_CONNECTION_KEY, value); + if (ret != E_OK) { + LOGE("query NETWORK_CONNECTION_KEY failed"); + settingsDataMap_.Erase(NETWORK_CONNECTION_KEY); + return ret; + } + settingsDataMap_.EnsureInsert(NETWORK_CONNECTION_KEY, value); + return E_OK; +} + +int32_t SettingsDataManager::QueryLocalSpaceFreeStatus() +{ + std::string value; + int32_t ret = QueryParamInSettingsData(LOCAL_SPACE_FREE_KEY, value); + if (ret != E_OK) { + LOGE("query LOCAL_SPACE_FREE_KEY failed"); + settingsDataMap_.Erase(LOCAL_SPACE_FREE_KEY); + return ret; + } + settingsDataMap_.EnsureInsert(LOCAL_SPACE_FREE_KEY, value); + return E_OK; +} + +int32_t SettingsDataManager::QueryLocalSpaceFreeDays() +{ + std::string value; + int32_t ret = QueryParamInSettingsData(LOCAL_SPACE_DAYS_KEY, value); + if (ret != E_OK) { + LOGE("query LOCAL_SPACE_DAYS_KEY failed"); + settingsDataMap_.Erase(LOCAL_SPACE_DAYS_KEY); + return ret; + } + settingsDataMap_.EnsureInsert(LOCAL_SPACE_DAYS_KEY, value); + return E_OK; +} + +int32_t SettingsDataManager::QueryMobileDataStatus() +{ + std::string value; + int32_t ret = QueryParamInSettingsData(MOBILE_DATA_SYNC_KEY, value); + if (ret != E_OK) { + LOGE("query MOBILE_DATA_SYNC_KEY failed"); + settingsDataMap_.Erase(MOBILE_DATA_SYNC_KEY); + return ret; + } + settingsDataMap_.EnsureInsert(MOBILE_DATA_SYNC_KEY, value); + return E_OK; +} + +SwitchStatus SettingsDataManager::GetSwitchStatus() +{ + std::string value; + int32_t ret = QuerySwitchStatus(); + if (ret == E_INNER_RDB) { + return SwitchStatus::CLOUD_SPACE; + } else if (ret == E_RDB) { + return SwitchStatus::NONE; + } + + value = settingsDataMap_.ReadVal(SYNC_SWITCH_KEY); + if (value == AI_FAMILY_STATUS) { + return SwitchStatus::AI_FAMILY; + } else if (value == CLOUD_STATUS) { + return SwitchStatus::CLOUD_SPACE; + } else { + return SwitchStatus::NONE; + } +} + +SwitchStatus SettingsDataManager::GetSwitchStatusByCache() +{ + std::string value; + if (!settingsDataMap_.Find(SYNC_SWITCH_KEY, value)) { + return GetSwitchStatus(); + } + + value = settingsDataMap_.ReadVal(SYNC_SWITCH_KEY); + if (value == AI_FAMILY_STATUS) { + return SwitchStatus::AI_FAMILY; + } else if (value == CLOUD_STATUS) { + return SwitchStatus::CLOUD_SPACE; + } else { + return SwitchStatus::NONE; + } +} + +std::string SettingsDataManager::GetNetworkConnectionStatus() +{ + std::string value; + if (!settingsDataMap_.Find(NETWORK_CONNECTION_KEY, value)) { + if (QueryNetworkConnectionStatus() != E_OK) { + return SUCCESS_STATUS; + } + } + + value = settingsDataMap_.ReadVal(NETWORK_CONNECTION_KEY); + return value; +} + +int32_t SettingsDataManager::GetLocalSpaceFreeStatus() +{ + std::string value; + if (!settingsDataMap_.Find(LOCAL_SPACE_FREE_KEY, value)) { + if (QueryLocalSpaceFreeStatus() != E_OK) { + return 0; + } + } + + value = settingsDataMap_.ReadVal(LOCAL_SPACE_FREE_KEY); + return std::stol(value); +} + +int32_t SettingsDataManager::GetLocalSpaceFreeDays() +{ + std::string value; + if (!settingsDataMap_.Find(LOCAL_SPACE_DAYS_KEY, value)) { + if (QueryLocalSpaceFreeDays() != E_OK) { + return 0; + } + } + + value = settingsDataMap_.ReadVal(LOCAL_SPACE_DAYS_KEY); + return std::stol(value); +} + +std::string SettingsDataManager::GetMobileDataStatus() +{ + std::string value; + if (!settingsDataMap_.Find(MOBILE_DATA_SYNC_KEY, value)) { + if (QueryMobileDataStatus() != E_OK) { + return SUCCESS_STATUS; + } + } + + value = settingsDataMap_.ReadVal(MOBILE_DATA_SYNC_KEY); + return value; +} + +int32_t SettingsDataManager::QueryParamInSettingsData(const std::string &key, std::string &value) +{ + LOGI("Query key: %{public}s", key.c_str()); + DataShare::DataSharePredicates predicates; + predicates.EqualTo("KEYWORD", key); + std::vector columns = {"value"}; + DataShare::CreateOptions options; + options.enabled_ = true; + auto dataShareHelper = DataShare::DataShareHelper::Creator(SETTING_DATA_QUERY_URI, options); + if (dataShareHelper == nullptr) { + LOGE("dataShareHelper == nullptr"); + return E_RDB; + } + + std::string queryUri = SETTING_DATA_COMMON_URI + "&key=" + key; + Uri uri(queryUri); + std::shared_ptr resultSet = dataShareHelper->Query(uri, predicates, columns); + dataShareHelper->Release(); + if (resultSet == nullptr) { + LOGE("resultSet == nullptr"); + return E_RDB; + } + if (resultSet->GoToFirstRow() != E_OK) { + LOGW("not found key: %{public}s", key.c_str()); + return E_INNER_RDB; + } + int32_t columnIndex = 0; + if (resultSet->GetColumnIndex("value", columnIndex) != E_OK) { + LOGE("GetColumnIndex failed"); + return E_RDB; + } + if (resultSet->GetString(columnIndex, value) != E_OK) { + LOGE("GetString failed"); + return E_RDB; + } + + LOGI("Query success, value: %{public}s", value.c_str()); + return E_OK; +} + +void SettingsDataManager::RegisterObserver(const std::string &key) +{ + LOGD("register key: %{public}s", key.c_str()); + DataShare::CreateOptions options; + options.enabled_ = true; + auto dataShareHelper = DataShare::DataShareHelper::Creator(SETTING_DATA_QUERY_URI, options); + if (dataShareHelper == nullptr) { + LOGE("dataShareHelper == nullptr"); + return; + } + sptr dataObserver(new (std::nothrow) SettingsDataObserver(key)); + Uri observerUri(SETTING_DATA_COMMON_URI + "&key=" + key); + dataShareHelper->RegisterObserver(observerUri, dataObserver); + dataShareHelper->Release(); + LOGI("Register SettingsDataObserver key: %{public}s finish", key.c_str()); +} + +void SettingsDataManager::RegisterObserver(const std::string &key, sptr dataObserver) +{ + LOGD("register key: %{public}s", key.c_str()); + DataShare::CreateOptions options; + options.enabled_ = true; + auto dataShareHelper = DataShare::DataShareHelper::Creator(SETTING_DATA_QUERY_URI, options); + if (dataShareHelper == nullptr) { + LOGE("dataShareHelper == nullptr"); + return; + } + + Uri observerUri(SETTING_DATA_COMMON_URI + "&key=" + key); + dataShareHelper->RegisterObserver(observerUri, dataObserver); + dataShareHelper->Release(); + LOGI("Register SettingsDataObserver key: %{public}s finish", key.c_str()); +} + +void SettingsDataManager::UnregisterObserver(const std::string &key) +{ + DataShare::CreateOptions options; + options.enabled_ = true; + auto dataShareHelper = DataShare::DataShareHelper::Creator(SETTING_DATA_QUERY_URI, options); + if (dataShareHelper == nullptr) { + LOGE("dataShareHelper == nullptr"); + return; + } + sptr dataObserver(new (std::nothrow) SettingsDataObserver(key)); + Uri observerUri(SETTING_DATA_COMMON_URI + "&key=" + key); + dataShareHelper->UnregisterObserver(observerUri, dataObserver); + dataShareHelper->Release(); + LOGI("Unregister SettingsDataObserver key: %{public}s finish", key.c_str()); +} + +void SettingsDataObserver::OnChange() +{ + LOGD("change key: %{public}s", key_.c_str()); + if (key_ == SYNC_SWITCH_KEY) { + SettingsDataManager::QuerySwitchStatus(); + } else if (key_ == NETWORK_CONNECTION_KEY) { + SettingsDataManager::QueryNetworkConnectionStatus(); + } else if (key_ == LOCAL_SPACE_FREE_KEY) { + SettingsDataManager::QueryLocalSpaceFreeStatus(); + } else if (key_ == LOCAL_SPACE_DAYS_KEY) { + SettingsDataManager::QueryLocalSpaceFreeDays(); + } else if (key_ == MOBILE_DATA_SYNC_KEY) { + SettingsDataManager::QueryMobileDataStatus(); + } +} +} \ No newline at end of file diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn b/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn index af582e30112ec0d7ac106ad67bd16c3275d63cba..581e69e77a1cedd026c531c604f22dc9cbe1ef05 100644 --- a/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn +++ b/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn @@ -68,6 +68,7 @@ ohos_shared_library("cloudfile_kit") { "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_set_manager.cpp", "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/network_status.cpp", "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/screen_status.cpp", + "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/settings_data_manager.cpp", "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/system_load.cpp", ] @@ -164,6 +165,7 @@ ohos_shared_library("cloudfile_kit_core") { "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/cloud_file_kit.cpp", "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/cloud_sync_helper.cpp", "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/data_sync_manager.cpp", + "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/settings_data_manager.cpp", ] sources += big_data_statistics @@ -176,7 +178,9 @@ ohos_shared_library("cloudfile_kit_core") { public_configs = [ ":cloudfile_kit_lite_public_config" ] external_deps = [ + "ability_runtime:dataobs_manager", "c_utils:utils", + "data_share:datashare_consumer", "hilog:libhilog", "hisysevent:libhisysevent", "ipc:ipc_core", diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_const.h b/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_const.h index 470877acccf13d3e016bb9a59d257325258fc32b..882cee62981dcca2bb38fa9a02f3218b97f3b33f 100644 --- a/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_const.h +++ b/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_const.h @@ -80,6 +80,8 @@ const int32_t DIRECTORY = 1; const int32_t MILLISECOND_TO_SECOND = 1000; const int32_t SECOND_TO_MILLISECOND = 1000; const int64_t MILLISECOND_TO_NANOSECOND = 1e6; +const uint64_t TWELVE_HOURS_MICROSECOND = 12 * 60 * 60 * MILLISECOND_TO_NANOSECOND; +const int32_t MICROSECOND_TIME_LENGTH_LIMIT = 16; const int32_t NOT_IN_TRASH = 0; const int32_t NOT_IN_PENDING = 0; @@ -87,6 +89,7 @@ const int32_t NOT_HIDDEN = 0; const int32_t NOT_TEMP_FILE = 0; const int32_t IS_BURST_COVER = 1; +const std::string HDC_BUNDLE_NAME = "com.ohos.ailife"; const std::string GALLERY_BUNDLE_NAME = "com.ohos.photos"; const std::string MEDIALIBRARY_BUNDLE_NAME = "com.ohos.medialibrary.medialibrarydata"; @@ -99,6 +102,8 @@ static const std::string CLOUDSYNC_STATUS_FINISH = "4"; static const std::string CLOUDSYNC_STATUS_SWITCHOFF = "5"; static const std::string CLOUDSYNC_STATUS_CLEANING = "6"; +static const std::string CLOUDSYNC_SWITCH_STATUS = "persist.kernel.cloudsync.switch_status"; + static inline uint64_t GetCurrentTimeStamp() { struct timespec t; diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/data_syncer_rdb_store.h b/interfaces/inner_api/native/cloud_file_kit_inner/data_syncer_rdb_store.h index 21920b9d2d6303f2c2b5691dee0587be455ccacd..da2dbb6c80219b1e7ac0b15155be69303a564aca 100644 --- a/interfaces/inner_api/native/cloud_file_kit_inner/data_syncer_rdb_store.h +++ b/interfaces/inner_api/native/cloud_file_kit_inner/data_syncer_rdb_store.h @@ -28,6 +28,7 @@ public: ~DataSyncerRdbStore() = default; int32_t Insert(int32_t userId, const std::string &bundleName); + int32_t Delete(int32_t userId, const std::string &bundleName); int32_t UpdateSyncState(int32_t userId, const std::string &bundleName, CloudSyncState cloudSyncState, ErrorType errorType); int32_t GetLastSyncTime(int32_t userId, const std::string &bundleName, int64_t &time); diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/settings_data_manager.h b/interfaces/inner_api/native/cloud_file_kit_inner/settings_data_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..bb178cbcb1c4edd18a70bbfcb64d21497aaa2d1a --- /dev/null +++ b/interfaces/inner_api/native/cloud_file_kit_inner/settings_data_manager.h @@ -0,0 +1,69 @@ +/* + * 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 OHOS_FILEMGMT_CLOUD_SYNC_SETTINGS_DATA_MANAGER_H +#define OHOS_FILEMGMT_CLOUD_SYNC_SETTINGS_DATA_MANAGER_H + +#include + +#include "data_ability_observer_stub.h" +#include "safe_map.h" + +namespace OHOS::FileManagement::CloudSync { +enum SwitchStatus { + NONE = 0, + CLOUD_SPACE, + AI_FAMILY, +}; + +class SettingsDataObserver : public AAFwk::DataAbilityObserverStub { +public: + SettingsDataObserver(const std::string &key) : key_(key) {} + ~SettingsDataObserver() {} + void OnChange() override; + +private: + std::string key_; +}; + +class SettingsDataManager { +public: + static void InitSettingsDataManager(); + + static int32_t QuerySwitchStatus(); + static int32_t QueryNetworkConnectionStatus(); + static int32_t QueryLocalSpaceFreeStatus(); + static int32_t QueryLocalSpaceFreeDays(); + static int32_t QueryMobileDataStatus(); + + static SwitchStatus GetSwitchStatus(); + static SwitchStatus GetSwitchStatusByCache(); + static std::string GetNetworkConnectionStatus(); + static int32_t GetLocalSpaceFreeStatus(); + static int32_t GetLocalSpaceFreeDays(); + static std::string GetMobileDataStatus(); + + static void RegisterObserver(const std::string &key); + static void RegisterObserver(const std::string &key, sptr dataObserver); + +private: + static int32_t QueryParamInSettingsData(const std::string &key, std::string &value); + static void UnregisterObserver(const std::string &key); + + static inline SafeMap settingsDataMap_; +}; +} // OHOS + +#endif // OHOS_FILEMGMT_CLOUD_SYNC_SETTINGS_DATA_MANAGER_H \ No newline at end of file diff --git a/services/cloudfiledaemon/BUILD.gn b/services/cloudfiledaemon/BUILD.gn index b949a145253c0f0305ffc9471a905fc0d27a1473..ae5f0ea52e70cfe4b8add87d9aa3f3539cc3becc 100644 --- a/services/cloudfiledaemon/BUILD.gn +++ b/services/cloudfiledaemon/BUILD.gn @@ -55,6 +55,7 @@ ohos_shared_library("cloudfiledaemon") { "src/fuse_manager/fuse_manager.cpp", "src/ipc/cloud_daemon.cpp", "src/ipc/cloud_daemon_stub.cpp", + "src/utils/setting_data_helper.cpp", ] sources += cloud_disk @@ -71,10 +72,12 @@ ohos_shared_library("cloudfiledaemon") { "${utils_path}/ioctl/include", "${utils_path}/system/include", "${innerkits_native_path}/cloud_daemon_kit_inner", + "${innerkits_native_path}/cloud_file_kit_inner", "${innerkits_native_path}/cloud_file_kit_inner/big_data_statistics", "${services_path}/cloudfiledaemon/include/cloud_disk/", "${services_path}/cloudfiledaemon/include/fuse_manager/", "${services_path}/cloudfiledaemon/include/ipc/", + "${services_path}/cloudfiledaemon/include/utils/", "${services_path}/cloudsyncservice/include/data_sync/", "${clouddisk_database_path}/include", ] @@ -90,6 +93,7 @@ ohos_shared_library("cloudfiledaemon") { "ability_runtime:dataobs_manager", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "data_share:datashare_consumer", "ffrt:libffrt", "hilog:libhilog", "hisysevent:libhisysevent", diff --git a/services/cloudfiledaemon/include/utils/setting_data_helper.h b/services/cloudfiledaemon/include/utils/setting_data_helper.h new file mode 100644 index 0000000000000000000000000000000000000000..904b95b8bef53d6608152e0efcbae5e578a371c8 --- /dev/null +++ b/services/cloudfiledaemon/include/utils/setting_data_helper.h @@ -0,0 +1,55 @@ +/* + * 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 SETTING_DATA_HELPER_H +#define SETTING_DATA_HELPER_H +#include +#include + +#include "data_ability_observer_stub.h" + +namespace OHOS { +namespace FileManagement { +namespace CloudFile { +class SyncSwitchObserver : public AAFwk::DataAbilityObserverStub { +public: + SyncSwitchObserver() = default; + ~SyncSwitchObserver() = default; + void OnChange() override; +}; + +class SettingDataHelper { +public: + static SettingDataHelper &GetInstance(); + void SetUserData(void *data); + bool InitActiveBundle(); + void UpdateActiveBundle(); + +private: + std::string GetActiveBundle(); + bool IsDataShareReady(); + void RegisterObserver(); + void SetActiveBundle(std::string bundle); + +private: + void *data_ = nullptr; + bool isDataShareReady_ = false; + bool isBundleInited_ = false; + std::mutex dataMtx_; + std::mutex initMtx_; +}; +} // namespace CloudFile +} // namespace FileManagement +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/cloudfiledaemon/src/cloud_disk/account_status_listener.cpp b/services/cloudfiledaemon/src/cloud_disk/account_status_listener.cpp index 510686113b8712530027a5685b5798af682f9fea..c84147583cfa6fc76352b571950c7adda7613bf2 100644 --- a/services/cloudfiledaemon/src/cloud_disk/account_status_listener.cpp +++ b/services/cloudfiledaemon/src/cloud_disk/account_status_listener.cpp @@ -26,6 +26,7 @@ #include "file_operations_helper.h" #include "fuse_manager.h" #include "meta_file.h" +#include "setting_data_helper.h" #include "utils_log.h" namespace OHOS { @@ -78,6 +79,9 @@ void AccountStatusSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &ev } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED) { LOGI("Package removed and Clean clouddisk!"); RemovedClean(eventData); + } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY) { + bool ret = CloudFile::SettingDataHelper::GetInstance().InitActiveBundle(); + LOGI("READY: Init active bundle, ret: %{public}d", ret); } } @@ -88,12 +92,13 @@ AccountStatusListener::~AccountStatusListener() void AccountStatusListener::Start() { - /* subscribe Account login and logout status */ + /* subscribe Account login, logout, Package remove and Datashare ready */ EventFwk::MatchingSkills matchingSkills; matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGIN); matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT); matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF); matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED); + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); EventFwk::CommonEventSubscribeInfo info(matchingSkills); commonEventSubscriber_ = std::make_shared(info); auto subRet = EventFwk::CommonEventManager::SubscribeCommonEvent(commonEventSubscriber_); diff --git a/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp b/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp index 62821854d2a3b0216da254d5c1e201c9be5b6b7a..b598245d830d28dd74851902bc2914dc8d4af731 100644 --- a/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp +++ b/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp @@ -58,6 +58,7 @@ #include "fuse_ioctl.h" #include "fuse_operations.h" #include "parameters.h" +#include "setting_data_helper.h" #ifdef HICOLLIE_ENABLE #include "xcollie_helper.h" #endif @@ -85,6 +86,7 @@ static const string LOCAL_PATH_SUFFIX = "/account/device_view/local"; static const string CLOUD_MERGE_VIEW_PATH_SUFFIX = "/account/cloud_merge_view"; static const string PATH_TEMP_SUFFIX = ".temp.fuse"; static const string PHOTOS_BUNDLE_NAME = "com.ohos.photos"; +static const string HDC_BUNDLE_NAME = "com.ohos.ailife"; static const string PATH_INVALID_FLAG1 = "../"; static const string PATH_INVALID_FLAG2 = "/.."; static const uint32_t PATH_INVALID_FLAG_LEN = 3; @@ -251,6 +253,7 @@ struct FuseData { shared_ptr database; struct fuse_session *se; string photoBundleName{""}; + string activeBundle{PHOTOS_BUNDLE_NAME}; }; static shared_ptr FindKeyInCloudFdCache(struct FuseData *data, uint64_t key) @@ -400,7 +403,7 @@ static shared_ptr GetDatabase(struct FuseData *data) return nullptr; } - data->database = instance->GetCloudDatabase(data->userId, PHOTOS_BUNDLE_NAME); + data->database = instance->GetCloudDatabase(data->userId, data->activeBundle); if (data->database == nullptr) { LOGE("get cloud file kit database fail"); return nullptr; @@ -909,6 +912,11 @@ static bool IsLocalFile(struct FuseData *data, shared_ptr cInode) return access(localPath.c_str(), F_OK) == 0; } +static bool IsHdc(struct FuseData *data) +{ + return data->activeBundle == HDC_BUNDLE_NAME; +} + static bool NeedReCloudOpen(struct FuseData *data, shared_ptr cInode) { if (cInode->mBase->fileType == FILE_TYPE_CONTENT) { @@ -979,7 +987,7 @@ static void CloudOpenHelper(fuse_req_t req, fuse_ino_t ino, struct fuse_file_inf struct FuseData *data, shared_ptr& cInode) { pid_t pid = GetPidFromTid(req->ctx.pid); - string recordId = MetaFileMgr::GetInstance().CloudIdToRecordId(cInode->mBase->cloudId); + string recordId = MetaFileMgr::GetInstance().CloudIdToRecordId(cInode->mBase->cloudId, IsHdc(data)); shared_ptr database = GetDatabase(data); std::unique_lock wSesLock(cInode->sessionLock, std::defer_lock); string prepareTraceId = GetPrepareTraceId(data->userId); @@ -1865,6 +1873,8 @@ static int SetNewSessionInfo(struct fuse_session *se, struct fuse_loop_config &c } else { LOGE("get cloudfile helper instance failed"); } + // update userdata + SettingDataHelper::GetInstance().SetUserData(nullptr); return ret; } @@ -1889,7 +1899,6 @@ int32_t FuseManager::StartFuse(int32_t userId, int32_t devFd, const string &path LOGE("FUSE: log failed"); return ; } - LOGE("FUSE: %{public}s", str); free(str); #pragma clang diagnostic pop @@ -1914,11 +1923,11 @@ int32_t FuseManager::StartFuse(int32_t userId, int32_t devFd, const string &path data.userId = userId; data.se = se; data.photoBundleName = system::GetParameter(PHOTOS_KEY, ""); + SettingDataHelper::GetInstance().SetUserData(&data); config.max_idle_threads = MAX_IDLE_THREADS; } LOGI("fuse_session_new success, userId: %{public}d", userId); - int ret = SetNewSessionInfo(se, config, devFd, path, userId); - return ret; + return SetNewSessionInfo(se, config, devFd, path, userId); } struct fuse_session* FuseManager::GetSession(std::string path) @@ -1938,6 +1947,20 @@ FuseManager &FuseManager::GetInstance() return instance_; } +void SettingDataHelper::SetActiveBundle(string bundle) +{ + lock_guard lck(dataMtx_); + if (data_ == nullptr) { + LOGI("FuseData is null, no need update"); + return; + } + struct FuseData *data = static_cast(data_); + LOGI("reset database, old: %{public}s new: %{public}s", data->activeBundle.c_str(), bundle.c_str()); + if (data->activeBundle != bundle) { + data->activeBundle = bundle; + data->database = nullptr; + } +} } // namespace CloudFile } // namespace FileManagement } // namespace OHOS diff --git a/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp b/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp index 1876808a89046b5363a2ba7036b1f3fa9676dd80..5a999e9d8f5d3c44b877bb2ca4e64bd3592965fb 100644 --- a/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp +++ b/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp @@ -30,6 +30,7 @@ #include "iremote_object.h" #include "parameters.h" #include "plugin_loader.h" +#include "setting_data_helper.h" #include "system_ability_definition.h" #include "utils_directory.h" #include "utils_log.h" @@ -107,6 +108,7 @@ void CloudDaemon::OnStart() try { PublishSA(); AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID); + AddSystemAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID); mode_t mode = 002; umask(mode); ModSysParam(); @@ -178,6 +180,11 @@ void CloudDaemon::OnAddSystemAbility(int32_t systemAbilityId, const std::string { LOGI("OnAddSystemAbility systemAbilityId:%{public}d added!", systemAbilityId); accountStatusListener_->Start(); + // get setting data when sa load + if (systemAbilityId == DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID) { + bool ret = SettingDataHelper::GetInstance().InitActiveBundle(); + LOGI("SERVICE LOAD: Init active bundle, ret: %{public}d", ret); + } } void CloudDaemon::ExecuteStartFuse(int32_t userId, int32_t devFd, const std::string& path) diff --git a/services/cloudfiledaemon/src/utils/setting_data_helper.cpp b/services/cloudfiledaemon/src/utils/setting_data_helper.cpp new file mode 100644 index 0000000000000000000000000000000000000000..40f1173911b5cf1790d0866b84a67fe1bc7cbf3a --- /dev/null +++ b/services/cloudfiledaemon/src/utils/setting_data_helper.cpp @@ -0,0 +1,108 @@ +/* + * 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 "setting_data_helper.h" + +#include "data_sync_const.h" +#include "datashare_helper.h" +#include "settings_data_manager.h" +#include "utils_log.h" + +namespace OHOS { +namespace FileManagement { +namespace CloudFile { +using namespace std; +using namespace OHOS::FileManagement::CloudSync; +namespace { +static const string SETTING_DATA_QUERY_URI = "datashareproxy://"; +static const string SYNC_SWITCH_KEY = "photos_sync_options"; +} // namespace + +SettingDataHelper &SettingDataHelper::GetInstance() +{ + static SettingDataHelper instance_; + return instance_; +} + +void SettingDataHelper::SetUserData(void *data) +{ + lock_guard lck(dataMtx_); + data_ = data; +} + +bool SettingDataHelper::IsDataShareReady() +{ + if (isDataShareReady_) { + return true; + } + // try get DataShareHelper + DataShare::CreateOptions options; + options.enabled_ = true; + auto dataShareHelper = DataShare::DataShareHelper::Creator(SETTING_DATA_QUERY_URI, options); + if (dataShareHelper == nullptr) { + LOGE("get data share helper fail, will retry again after recv ready event"); + return false; + } + bool ret = dataShareHelper->Release(); + LOGI("release data share helper, ret=%{public}d", ret); + isDataShareReady_ = true; + return true; +} + +string SettingDataHelper::GetActiveBundle() +{ + // get from datashare + SwitchStatus status = SettingsDataManager::GetSwitchStatus(); + if (status == AI_FAMILY) { + return HDC_BUNDLE_NAME; + } + return GALLERY_BUNDLE_NAME; +} + +bool SettingDataHelper::InitActiveBundle() +{ + lock_guard lck(initMtx_); + if (isBundleInited_) { + return true; + } + if (!IsDataShareReady()) { + return false; + } + UpdateActiveBundle(); + RegisterObserver(); + isBundleInited_ = true; + return true; +} + +void SettingDataHelper::UpdateActiveBundle() +{ + // get latest data + string bundle = GetActiveBundle(); + // update FuseData + SetActiveBundle(bundle); +} + +void SettingDataHelper::RegisterObserver() +{ + sptr observer(new (std::nothrow) SyncSwitchObserver()); + SettingsDataManager::RegisterObserver(SYNC_SWITCH_KEY, observer); +} + +void SyncSwitchObserver::OnChange() +{ + SettingDataHelper::GetInstance().UpdateActiveBundle(); +} +} // namespace CloudFile +} // namespace FileManagement +} // namespace OHOS \ No newline at end of file diff --git a/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp b/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp index a2f66a5428b0f20ad1e3034a5280e92d64f5a290..7fbfcf39fe0be6f73d526cd4de49b09e1f2c87d4 100644 --- a/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp +++ b/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp @@ -24,8 +24,10 @@ namespace FileManagement { namespace CloudSync { static const std::string FILEMANAGER_KEY = "persist.kernel.bundle_name.filemanager"; OptimizeCacheTask::OptimizeCacheTask(std::shared_ptr dataSyncManager) - : CycleTask("optimize_cache_task", {"com.ohos.photos", system::GetParameter(FILEMANAGER_KEY, "")}, ONE_DAY, - dataSyncManager) + : CycleTask("optimize_cache_task", + {GALLERY_BUNDLE_NAME, system::GetParameter(FILEMANAGER_KEY, ""), HDC_BUNDLE_NAME}, + ONE_DAY, + dataSyncManager) {} int32_t OptimizeCacheTask::RunTaskForBundle(int32_t userId, std::string bundleName) diff --git a/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp b/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp index 705e994927a015e953556aa4271bbb13800c72a5..420a1b9eaf9f894dacb6726d4369766dd4dd74ac 100644 --- a/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp +++ b/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp @@ -15,6 +15,7 @@ #include "optimize_storage_task.h" #include "cloud_file_kit.h" +#include "settings_data_manager.h" #include "system_load.h" #include "utils_log.h" @@ -22,7 +23,7 @@ namespace OHOS { namespace FileManagement { namespace CloudSync { OptimizeStorageTask::OptimizeStorageTask(std::shared_ptr dataSyncManager) - : CycleTask("optimize_storage_task", {"com.ohos.photos"}, ONE_DAY, dataSyncManager) + : CycleTask("optimize_storage_task", {GALLERY_BUNDLE_NAME, HDC_BUNDLE_NAME}, ONE_DAY, dataSyncManager) { } @@ -41,15 +42,23 @@ int32_t OptimizeStorageTask::RunTaskForBundle(int32_t userId, std::string bundle if (dataSyncManager_->CleanRemainFile(bundleName, userId) != E_OK) { LOGW(" clean reamin file fail"); } - std::map param; - auto ret = instance->GetAppConfigParams(userId, bundleName, param); - if (ret != E_OK || param.empty()) { - LOGE("GetAppConfigParams failed"); - return ret; + + int32_t agingDays = -1; + int32_t agingPolicy = -1; + if (bundleName == HDC_BUNDLE_NAME) { + agingDays = SettingsDataManager::GetLocalSpaceFreeDays(); + agingPolicy = SettingsDataManager::GetLocalSpaceFreeStatus(); + } else { + std::map param; + auto ret = instance->GetAppConfigParams(userId, bundleName, param); + if (ret != E_OK || param.empty()) { + LOGE("GetAppConfigParams failed"); + return ret; + } + agingDays = std::stoi(param["validDays"]); + agingPolicy = std::stoi(param["dataAgingPolicy"]); } - int32_t agingDays = std::stoi(param["validDays"]); - int32_t agingPolicy = std::stoi(param["dataAgingPolicy"]); if (agingPolicy == 0) { return dataSyncManager_->OptimizeStorage(bundleName, userId, agingDays); } diff --git a/services/cloudsyncservice/src/cycle_task/tasks/report_statistics_task.cpp b/services/cloudsyncservice/src/cycle_task/tasks/report_statistics_task.cpp index 98d290d71fdf89146fadabae56c8e62519a700e8..9070243f888595dcbd4f4de06f497647f66583bc 100644 --- a/services/cloudsyncservice/src/cycle_task/tasks/report_statistics_task.cpp +++ b/services/cloudsyncservice/src/cycle_task/tasks/report_statistics_task.cpp @@ -21,7 +21,7 @@ namespace OHOS { namespace FileManagement { namespace CloudSync { ReportStatisticsTask::ReportStatisticsTask(std::shared_ptr dataSyncManager) - : CycleTask("report_statistics_task", {"com.ohos.photos"}, ONE_DAY, dataSyncManager) + : CycleTask("report_statistics_task", {GALLERY_BUNDLE_NAME, HDC_BUNDLE_NAME}, ONE_DAY, dataSyncManager) { } diff --git a/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp b/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp index 5a946abe474b964b43cafbbb0505e88b2097b6bf..1a0f3314ec57d1db20921bdc649fc23ae5959b7e 100644 --- a/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp +++ b/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp @@ -43,6 +43,7 @@ #include "system_load.h" #include "task_state_manager.h" #include "utils_log.h" +#include "settings_data_manager.h" namespace OHOS::FileManagement::CloudSync { using namespace std; @@ -194,6 +195,7 @@ void CloudSyncService::OnStart(const SystemAbilityOnDemandReason& startReason) TaskStateManager::GetInstance().StartTask(); // 跟随进程生命周期 ffrt::submit([startReason, this]() { + SettingsDataManager::InitSettingsDataManager(); this->HandleStartReason(startReason); int32_t userId = 0; if (dataSyncManager_->GetUserId(userId) != E_OK) { @@ -689,7 +691,11 @@ int32_t CloudSyncService::ChangeAppSwitch(const std::string &accoutId, const std LOGI("Begin ChangeAppSwitch"); RETURN_ON_ERR(CheckPermissions("", true)); - auto callerUserId = DfsuAccessTokenHelper::GetUserId(); + int32_t callerUserId = DfsuAccessTokenHelper::GetUserId(); + /* SA is 0 */ + if (callerUserId == 0) { + DfsuAccessTokenHelper::GetAccountId(callerUserId); + } LOGI("ChangeAppSwitch, bundleName: %{private}s, status: %{public}d, callerUserId: %{public}d", bundleName.c_str(), status, callerUserId); @@ -761,9 +767,13 @@ int32_t CloudSyncService::DisableCloud(const std::string &accoutId) LOGI("Begin DisableCloud"); RETURN_ON_ERR(CheckPermissions(PERM_CLOUD_SYNC_MANAGER, true)); - auto callerUserId = DfsuAccessTokenHelper::GetUserId(); + int32_t callerUserId = DfsuAccessTokenHelper::GetUserId(); + /* SA is 0 */ + if (callerUserId == 0) { + DfsuAccessTokenHelper::GetAccountId(callerUserId); + } int32_t ret = dataSyncManager_->DisableCloud(callerUserId); - LOGI("End DisableCloud"); + LOGI("End DisableCloud, ret: %{public}d", ret); return ret; } diff --git a/test/unittests/cloud_disk/BUILD.gn b/test/unittests/cloud_disk/BUILD.gn index 68d5126875b1949712604046ecdd0369f26dc176..1863ca407c08f81b9ea284b45eef9ba9df3b31dd 100644 --- a/test/unittests/cloud_disk/BUILD.gn +++ b/test/unittests/cloud_disk/BUILD.gn @@ -27,6 +27,7 @@ ohos_unittest("account_status_listener_test") { "${services_path}/cloudfiledaemon/include/", "${services_path}/cloudfiledaemon/include/cloud_disk/", "${services_path}/cloudfiledaemon/include/fuse_manager/", + "${services_path}/cloudfiledaemon/include/utils/", ] sources = [ @@ -35,11 +36,13 @@ ohos_unittest("account_status_listener_test") { "${services_path}/cloudfiledaemon/src/cloud_disk/file_operations_helper.cpp", "${services_path}/cloudfiledaemon/src/fuse_manager/cloud_daemon_statistic.cpp", "${services_path}/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp", + "${services_path}/cloudfiledaemon/src/utils/setting_data_helper.cpp", "account_status_listener_test.cpp", ] deps = [ "${clouddisk_database_path}:clouddisk_database", + "${innerkits_native_path}/cloud_file_kit_inner:cloudfile_kit_core", "${innerkits_native_path}/cloudsync_kit_inner:cloudsync_kit_inner", "${innerkits_native_path}/cloudsync_kit_inner:cloudsync_kit_inner_lite", "${utils_path}:libdistributedfiledentry", @@ -49,8 +52,10 @@ ohos_unittest("account_status_listener_test") { external_deps = [ "ability_base:want", + "ability_runtime:dataobs_manager", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "data_share:datashare_consumer", "ffrt:libffrt", "googletest:gmock_main", "googletest:gtest_main", @@ -58,6 +63,7 @@ ohos_unittest("account_status_listener_test") { "hisysevent:libhisysevent", "hitrace:hitrace_meter", "init:libbegetutil", + "ipc:ipc_single", "libfuse:libfuse", "relational_store:native_rdb", ] diff --git a/test/unittests/cloud_disk/account_status_listener_test.cpp b/test/unittests/cloud_disk/account_status_listener_test.cpp index c6afd037c9e717914def4baa0bd6e191247df340..220afb725d1892ffe1fa0ec6cd0dbc438baa8ffa 100644 --- a/test/unittests/cloud_disk/account_status_listener_test.cpp +++ b/test/unittests/cloud_disk/account_status_listener_test.cpp @@ -19,11 +19,13 @@ #include "account_status_listener.h" #include "common_event_manager.h" #include "common_event_support.h" +#include "setting_data_helper.h" namespace OHOS::FileManagement::CloudDisk::Test { using namespace testing; using namespace testing::ext; using namespace std; +using namespace OHOS::FileManagement::CloudFile; using Want = OHOS::AAFwk::Want; constexpr int32_t USER_ID = 101; @@ -46,6 +48,7 @@ void AccountStatusListenerTest::SetUpTestCase(void) matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGIN); matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT); matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED); + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); subscribeInfo_ = make_shared(matchingSkills); accountStatusSubscriber_ = make_shared(*subscribeInfo_); accountStatusListener_ = make_shared(); @@ -135,6 +138,30 @@ HWTEST_F(AccountStatusListenerTest, OnReceiveEventTest003, TestSize.Level1) GTEST_LOG_(INFO) << "OnReceiveEventTest003 End"; } +/** + * @tc.name: OnReceiveEventTest004 + * @tc.desc: Verify the OnReceiveEvent function + * @tc.type: FUNC + */ +HWTEST_F(AccountStatusListenerTest, OnReceiveEventTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnReceiveEventTest004 Start"; + try { + Want want; + want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); + string data(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); + EventFwk::CommonEventData eventData(want, USER_ID, data); + + SettingDataHelper::GetInstance().isBundleInited_ = true; + accountStatusSubscriber_->OnReceiveEvent(eventData); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnReceiveEventTest004 ERROR"; + } + GTEST_LOG_(INFO) << "OnReceiveEventTest004 End"; +} + /** * @tc.name: StopTest001 * @tc.desc: Verify the Stop function diff --git a/test/unittests/cloud_file_kit_inner/data_sync/sync_state_manager_test.cpp b/test/unittests/cloud_file_kit_inner/data_sync/sync_state_manager_test.cpp index be060ad7462a043529c4ae023b793ed66546ccac..53f8cdc359bc9acb9f9fe86e34a362080333cddb 100644 --- a/test/unittests/cloud_file_kit_inner/data_sync/sync_state_manager_test.cpp +++ b/test/unittests/cloud_file_kit_inner/data_sync/sync_state_manager_test.cpp @@ -12,14 +12,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "sync_state_manager.h" #include #include +#include "sync_state_manager.h" +#include "system_mock.h" +#include "data_sync_const.h" namespace OHOS::FileManagement::CloudSync::Test { using namespace testing; using namespace testing::ext; using namespace std; +using namespace system; class MockSyncStateManager : public SyncStateManager { public: @@ -504,4 +507,143 @@ HWTEST_F(SyncStateManagerTest, SyncStateManagerTest_022, TestSize.Level1) } GTEST_LOG_(INFO) << "SyncStateManagerTest_022 End"; } + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_001 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return("")); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, false); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_001 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_001 End"; +} + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_002 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return("0")); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, false); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_002 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_002 End"; +} + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_003 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return("xxx")); + EXPECT_CALL(*systemMock, SetParameter(_, _)).WillOnce(Return(true)); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, false); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_003 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_003 End"; +} + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_004 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return("123456789123456789")); + EXPECT_CALL(*systemMock, SetParameter(_, _)).WillOnce(Return(true)); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, false); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_004 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_004 End"; +} + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_005 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return("1")); + EXPECT_CALL(*systemMock, SetParameter(_, _)).WillOnce(Return(true)); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, false); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_005 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_005 End"; +} + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_006 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + uint64_t curTime = GetCurrentTimeStamp() - TWELVE_HOURS_MICROSECOND; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return(std::to_string(curTime))); + EXPECT_CALL(*systemMock, SetParameter(_, _)).WillOnce(Return(true)); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, false); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_006 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_006 End"; +} + +HWTEST_F(SyncStateManagerTest, CheckMediaLibCleaningTest_007, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_007 start"; + try { + std::shared_ptr systemMock = std::make_shared(); + ISystem::system_ = systemMock; + uint64_t curTime = GetCurrentTimeStamp() - 10; + EXPECT_CALL(*systemMock, GetParameter(_, _)).WillOnce(Return(std::to_string(curTime))); + SyncStateManager syncStateManager; + bool ret = syncStateManager.CheckMediaLibCleaning(); + EXPECT_EQ(ret, true); + + ISystem::system_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_007 ERROR"; + } + GTEST_LOG_(INFO) << "CheckMediaLibCleaningTest_007 End"; +} } \ No newline at end of file diff --git a/test/unittests/cloud_file_kit_inner/data_sync/system_mock.h b/test/unittests/cloud_file_kit_inner/data_sync/system_mock.h index eb273a44733339b7a7bd23e664ec4586e670b93a..633e5d533f6aaf1e83eaa126f0793edd92a47518 100644 --- a/test/unittests/cloud_file_kit_inner/data_sync/system_mock.h +++ b/test/unittests/cloud_file_kit_inner/data_sync/system_mock.h @@ -37,12 +37,18 @@ public: std::string GetParameter(const std::string &key, const std::string &def) { - return ISystem::system_->GetParameter(key, def); + if (ISystem::system_ != nullptr) { + return ISystem::system_->GetParameter(key, def); + } + return ""; } bool SetParameter(const std::string &key, const std::string &def) { - return ISystem::system_->SetParameter(key, def); + if (ISystem::system_ != nullptr) { + return ISystem::system_->SetParameter(key, def); + } + return true; } } // system } // OHOS diff --git a/test/unittests/cloudsync_sa/dentry/dentry_meta_file_test.cpp b/test/unittests/cloudsync_sa/dentry/dentry_meta_file_test.cpp index 43729e354ab6ac15e59d65938007b4e0a8ad74a9..3995d7b90cee8cca28170219689ba56eec1deea4 100644 --- a/test/unittests/cloudsync_sa/dentry/dentry_meta_file_test.cpp +++ b/test/unittests/cloudsync_sa/dentry/dentry_meta_file_test.cpp @@ -453,6 +453,69 @@ HWTEST_F(DentryMetaFileTest, RecordIdToCloudId002, TestSize.Level1) GTEST_LOG_(INFO) << "RecordIdToCloudId002 End"; } +/** + * @tc.name: CloudIdToRecordId001 + * @tc.desc: Verify the CloudIdToRecordId + * @tc.type: FUNC + */ +HWTEST_F(DentryMetaFileTest, CloudIdToRecordId001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudIdToRecordId001 Start"; + try { + std::string hexStr = "123456789"; + string cloudId = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr, true); + string reocrdId = MetaFileMgr::GetInstance().CloudIdToRecordId(cloudId, true); + EXPECT_EQ(reocrdId, hexStr); + MetaFileMgr::GetInstance().ClearAll(); + } catch (...) { + EXPECT_FALSE(false); + GTEST_LOG_(INFO) << "CloudIdToRecordId001 ERROR"; + } + GTEST_LOG_(INFO) << "CloudIdToRecordId001 End"; +} + +/** + * @tc.name:CloudIdToRecordId002 + * @tc.desc: Verify the CloudIdToRecordId + * @tc.type: FUNC + */ +HWTEST_F(DentryMetaFileTest, CloudIdToRecordId002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudIdToRecordId002 Start"; + try { + std::string hexStr = "1234567890"; + string cloudId = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr, true); + string reocrdId = MetaFileMgr::GetInstance().CloudIdToRecordId(cloudId, true); + EXPECT_EQ(reocrdId, hexStr); + MetaFileMgr::GetInstance().ClearAll(); + } catch (...) { + EXPECT_FALSE(false); + GTEST_LOG_(INFO) << "CloudIdToRecordId002 ERROR"; + } + GTEST_LOG_(INFO) << "CloudIdToRecordId002 End"; +} + +/** + * @tc.name:CloudIdToRecordId003 + * @tc.desc: Verify the CloudIdToRecordId + * @tc.type: FUNC + */ +HWTEST_F(DentryMetaFileTest, CloudIdToRecordId003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CloudIdToRecordId003 Start"; + try { + std::string hexStr = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + string cloudId = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr); + string reocrdId = MetaFileMgr::GetInstance().CloudIdToRecordId(cloudId, true); + EXPECT_EQ(reocrdId, hexStr); + MetaFileMgr::GetInstance().ClearAll(); + } catch (...) { + EXPECT_FALSE(false); + GTEST_LOG_(INFO) << "CloudIdToRecordId003 ERROR"; + } + GTEST_LOG_(INFO) << "CloudIdToRecordId003 End"; +} + /** * @tc.name: GetParentDir001 * @tc.desc: Verify the GetParentDir diff --git a/test/unittests/cloudsync_sa/mock/data_ability_observer_stub.cpp b/test/unittests/cloudsync_sa/mock/data_ability_observer_stub.cpp index 00f12bc8b7ff4d2bde630039785540df05525a3d..6a7b78f9d35d82fa6aed38e9a69006c8b56294b4 100644 --- a/test/unittests/cloudsync_sa/mock/data_ability_observer_stub.cpp +++ b/test/unittests/cloudsync_sa/mock/data_ability_observer_stub.cpp @@ -20,6 +20,7 @@ #include "ipc_skeleton.h" #include "common_utils.h" #include "string_ex.h" +#include "dataobs_mgr_changeinfo.h" namespace OHOS { namespace AAFwk { @@ -78,7 +79,6 @@ int32_t DataAbilityObserverStub::OnChangeExtInner(MessageParcel &data, MessagePa if (!ChangeInfo::Unmarshalling(changeInfo, data)) { return IPC_STUB_INVALID_DATA_ERR; } - OnChangeExt(changeInfo); return ERR_NONE; } diff --git a/test/unittests/cloudsync_sa/mock/datashare_helper.cpp b/test/unittests/cloudsync_sa/mock/datashare_helper.cpp index fe284e1c2316ec1de367cb0919b06f67a55dccff..d5e8c731e2a7451c4746ce80580b4183c8308f97 100644 --- a/test/unittests/cloudsync_sa/mock/datashare_helper.cpp +++ b/test/unittests/cloudsync_sa/mock/datashare_helper.cpp @@ -15,6 +15,7 @@ #include "datashare_helper.h" #include "datashare_result_set.h" +#include "datashare_helper_mock.h" namespace OHOS { namespace DataShare { @@ -27,6 +28,9 @@ DataSharePredicates *DataSharePredicates::EqualTo(const std::string &field, cons std::shared_ptr DataShareHelper::Creator( const std::string &strUri, const CreateOptions &options, const std::string &bundleName) { + if (DataShareHelperMock::proxy_ != nullptr) { + return DataShareHelperMock::proxy_->Creator(strUri, options, bundleName); + } if (instance_ != nullptr) { return instance_; } @@ -37,6 +41,9 @@ std::shared_ptr DataShareHelper::Creator( std::shared_ptr DataShareHelper::Query(Uri &uri, const DataSharePredicates &predicates, std::vector &columns, DatashareBusinessError *businessError) { + if (DataShareHelperMock::proxy_ != nullptr) { + return DataShareHelperMock::proxy_->Query(uri, predicates, columns, businessError); + } if (resultSet_ != nullptr) { return resultSet_; } diff --git a/test/unittests/cloudsync_sa/mock/datashare_helper_mock.h b/test/unittests/cloudsync_sa/mock/datashare_helper_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..7e211d639757dd6eda4e43f538a10c0a9a85e572 --- /dev/null +++ b/test/unittests/cloudsync_sa/mock/datashare_helper_mock.h @@ -0,0 +1,38 @@ +/* + * 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 DATASHARE_HELPER_MOCK_H +#define DATASHARE_HELPER_MOCK_H + +#include +#include +#include "datashare_helper.h" + +namespace OHOS { +namespace DataShare { +class DataShareHelperMock : public DataShareHelper { +public: + MOCK_METHOD3(Creator, std::shared_ptr(const std::string &, const CreateOptions &, + const std::string &)); + MOCK_METHOD4(Query, std::shared_ptr(Uri &, const DataSharePredicates &, + std::vector &, DatashareBusinessError *)); + MOCK_METHOD2(RegisterObserver, void(const Uri &, const sptr &)); + MOCK_METHOD2(UnregisterObserver, void(const Uri &, const sptr &)); + MOCK_METHOD0(Release, bool()); + static inline std::shared_ptr proxy_ = nullptr; +}; +} // namespace OHOS +} // namespace DataShare +#endif // DATASHARE_HELPER_MOCK_H \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/mock/datashare_result_set.cpp b/test/unittests/cloudsync_sa/mock/datashare_result_set.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a899cbf8f0cc1a42bcfad777ac16fe8090d9241c --- /dev/null +++ b/test/unittests/cloudsync_sa/mock/datashare_result_set.cpp @@ -0,0 +1,77 @@ +/* + * 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 "datashare_result_set.h" +#include "datashare_result_set_mock.h" + +namespace OHOS { +namespace DataShare { +int32_t DataShareResultSet::GetColumnIndex(const std::string &columnName, int32_t &columnIndex) +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->GetColumnIndex(columnName, columnIndex); + } + return 0; +} + +int32_t DataShareResultSet::GetString(int32_t columnIndex, std::string &value) +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->GetString(columnIndex, value); + } + return 0; +} + +int32_t DataShareResultSet::GetLong(int32_t columnIndex, int64_t &value) +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->GetLong(columnIndex, value); + } + return 0; +} + +int32_t DataShareResultSet::GetInt(int32_t columnIndex, int32_t &value) +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->GetInt(columnIndex, value); + } + return 0; +} + +int32_t DataShareResultSet::GoToFirstRow() +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->GoToFirstRow(); + } + return 0; +} + +int32_t DataShareResultSet::GoToNextRow() +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->GoToNextRow(); + } + return 0; +} + +int32_t DataShareResultSet::Close() +{ + if (DataShareResultSetMock::proxy_ != nullptr) { + return DataShareResultSetMock::proxy_->Close(); + } + return 0; +} +} // namespace OHOS +} // namespace DataShare \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/mock/datashare_result_set.h b/test/unittests/cloudsync_sa/mock/datashare_result_set.h index 0bf4b76449b62337fe2f8d7dd10a1cb2e6c04df7..2312f6a054808f4594ea4145650bbebd96c8c794 100644 --- a/test/unittests/cloudsync_sa/mock/datashare_result_set.h +++ b/test/unittests/cloudsync_sa/mock/datashare_result_set.h @@ -16,40 +16,21 @@ #ifndef DATASHARE_RESULT_SET_H #define DATASHARE_RESULT_SET_H +#include +#include + namespace OHOS { namespace DataShare { class DataShareResultSet { public: - static int GetColumnIndex(const std::string &columnName, int &columnIndex) - { - return 0; - } - static int GetString(int columnIndex, std::string &value) - { - return 0; - } - static int GetLong(int columnIndex, int64_t &value) - { - return 0; - } - static int GetInt(int columnIndex, int &value) - { - return 0; - } - static int GoToFirstRow() - { - return 0; - } - static int GoToNextRow() - { - return 0; - } - static int Close() - { - return 0; - } + static int32_t GetColumnIndex(const std::string &columnName, int32_t &columnIndex); + static int32_t GetString(int32_t columnIndex, std::string &value); + static int32_t GetLong(int32_t columnIndex, int64_t &value); + static int32_t GetInt(int32_t columnIndex, int32_t &value); + static int32_t GoToFirstRow(); + static int32_t GoToNextRow(); + static int32_t Close(); }; - } } #endif // DATASHARE_RESULT_SET_H \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/mock/datashare_result_set_mock.h b/test/unittests/cloudsync_sa/mock/datashare_result_set_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..a1afc1ea15020e1e588edf9ff901063efde9eddc --- /dev/null +++ b/test/unittests/cloudsync_sa/mock/datashare_result_set_mock.h @@ -0,0 +1,38 @@ +/* + * 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 DATASHARE_RESULT_SET_MOCK_H +#define DATASHARE_RESULT_SET_MOCK_H + +#include +#include +#include "datashare_result_set.h" + +namespace OHOS { +namespace DataShare { +class DataShareResultSetMock : public DataShareResultSet { +public: + MOCK_METHOD2(GetColumnIndex, int32_t(const std::string &, int32_t &)); + MOCK_METHOD2(GetString, int32_t(int32_t, std::string &)); + MOCK_METHOD2(GetLong, int32_t(int32_t, int64_t &)); + MOCK_METHOD2(GetInt, int32_t(int32_t, int32_t &)); + MOCK_METHOD0(GoToFirstRow, int32_t()); + MOCK_METHOD0(GoToNextRow, int32_t()); + MOCK_METHOD0(Close, int32_t()); + static inline std::shared_ptr proxy_ = nullptr; +}; +} +} +#endif // DATASHARE_RESULT_SET_MOCK_H \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/sync_rule/BUILD.gn b/test/unittests/cloudsync_sa/sync_rule/BUILD.gn index e9a240dabfdd7a96c129e6bdb0480af56a028633..291e504d180214c93a2a121e6f6b812ad9a5878d 100644 --- a/test/unittests/cloudsync_sa/sync_rule/BUILD.gn +++ b/test/unittests/cloudsync_sa/sync_rule/BUILD.gn @@ -185,6 +185,7 @@ ohos_unittest("cloud_status_test") { sources = [ "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/cloud_status.cpp", "${distributedfile_path}/test/mock/cloud_file_kit_mock.cpp", + "${distributedfile_path}/test/unittests/cloudsync_sa/mock/datashare_helper.cpp", "${distributedfile_path}/utils/log/src/dfs_error.cpp", "cloud_status_test.cpp", ] @@ -194,6 +195,7 @@ ohos_unittest("cloud_status_test") { "${services_path}/cloudsyncservice/include", "${distributedfile_path}/adapter/cloud_adapter_example/include", "${distributedfile_path}/test/mock", + "${distributedfile_path}/test/unittests/cloudsync_sa/mock", ] deps = [ @@ -561,6 +563,51 @@ ohos_unittest("package_status_listener_test") { use_exceptions = true } +ohos_unittest("settings_data_manager_test") { + branch_protector_ret = "pac_ret" + sanitize = { + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = true + blocklist = "${distributedfile_path}/cfi_blocklist.txt" + } + + module_out_path = "dfs_service/dfs_service" + sources = [ + "settings_data_manager_test.cpp", + "${distributedfile_path}/frameworks/native/cloud_file_kit_inner/src/sync_rule/settings_data_manager.cpp", + "${distributedfile_path}/test/unittests/cloudsync_sa/mock/data_ability_observer_stub.cpp", + "${distributedfile_path}/test/unittests/cloudsync_sa/mock/datashare_helper.cpp", + "${distributedfile_path}/test/unittests/cloudsync_sa/mock/datashare_result_set.cpp", + ] + + include_dirs = [ + "${distributedfile_path}/interfaces/inner_api/native/cloud_file_kit_inner", + "${distributedfile_path}/test/unittests/cloudsync_sa/mock", + "${utils_path}/log/include", + ] + + deps = [ + "${utils_path}:libdistributedfileutils", + ] + + external_deps = [ + "ability_base:zuri", + "ability_runtime:dataobs_manager", + "c_utils:utils", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "ipc:ipc_core", + "ipc:ipc_single", + ] + + defines = [ "private=public" ] + use_exceptions = true +} + group("cloudsync_sa_sync_rule_test") { testonly = true deps = [ @@ -572,6 +619,7 @@ group("cloudsync_sa_sync_rule_test") { ":network_status_test", ":package_status_listener_test", ":screen_status_listener_test", + ":settings_data_manager_test", ":system_load_test", ":user_status_listener_test", ] diff --git a/test/unittests/cloudsync_sa/sync_rule/cloud_status_test.cpp b/test/unittests/cloudsync_sa/sync_rule/cloud_status_test.cpp index 975c504a55a5312a40d725ef5675ebebfb99ba13..b9adbdfe5805df69c7749e61f48dafdd44606884 100644 --- a/test/unittests/cloudsync_sa/sync_rule/cloud_status_test.cpp +++ b/test/unittests/cloudsync_sa/sync_rule/cloud_status_test.cpp @@ -107,6 +107,36 @@ HWTEST_F(CloudStatusTest, GetCurrentCloudInfo003, TestSize.Level1) EXPECT_EQ(ret, E_RDB); } +/** + * @tc.name: GetCurrentCloudInfo004 + * @tc.desc: Verify the CloudStatus::GetCurrentCloudInfo function + * @tc.type: FUNC + * @tc.require: SR000HRKKA + */ +HWTEST_F(CloudStatusTest, GetCurrentCloudInfo004, TestSize.Level1) +{ + CloudStatus cloudStatus; + const string bundleName = "com.ohos.photos"; + const int32_t userId = 1; + auto ret = cloudStatus.GetCurrentCloudInfo(bundleName, userId); + EXPECT_EQ(ret, E_OK); +} + +/** + * @tc.name: GetCurrentCloudInfo005 + * @tc.desc: Verify the CloudStatus::GetCurrentCloudInfo function + * @tc.type: FUNC + * @tc.require: SR000HRKKA + */ +HWTEST_F(CloudStatusTest, GetCurrentCloudInfo005, TestSize.Level1) +{ + CloudStatus cloudStatus; + const string bundleName = "com.ohos.ailife"; + const int32_t userId = 1; + auto ret = cloudStatus.GetCurrentCloudInfo(bundleName, userId); + EXPECT_EQ(ret, E_OK); +} + /** * @tc.name: IsCloudStatusOkay001 * @tc.desc: Verify the CloudStatus::IsCloudStatusOkay function diff --git a/test/unittests/cloudsync_sa/sync_rule/network_set_manager_test.cpp b/test/unittests/cloudsync_sa/sync_rule/network_set_manager_test.cpp index ea58881f033fa66b7515a08c0cff3495b8e18df4..196289389e7a74229ef92b1862b67c9a7d4f55cb 100644 --- a/test/unittests/cloudsync_sa/sync_rule/network_set_manager_test.cpp +++ b/test/unittests/cloudsync_sa/sync_rule/network_set_manager_test.cpp @@ -321,4 +321,67 @@ HWTEST_F(NetworkSetManagerTest, GetConfigParams001, TestSize.Level1) } GTEST_LOG_(INFO) << "GetConfigParams End"; } + +/** + * @tc.name: InitNetworkSetManagerTest001 + * @tc.desc: Verify the GetConfigParams function when driveKit is not null. + * @tc.type: FUNC + * @tc.require: ICEGLJ + */ +HWTEST_F(NetworkSetManagerTest, InitNetworkSetManager001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitNetworkSetManager001 Start"; + try { + int32_t userId = 100; + string bundleName = "com.ohos.photos"; + NetworkSetManager::InitNetworkSetManager(bundleName, userId); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitNetworkSetManager001 FAILED"; + } + GTEST_LOG_(INFO) << "InitNetworkSetManager001 End"; +} + +/** + * @tc.name: InitNetworkSetManagerTest002 + * @tc.desc: Verify the GetConfigParams function when driveKit is not null. + * @tc.type: FUNC + * @tc.require: ICEGLJ + */ +HWTEST_F(NetworkSetManagerTest, InitNetworkSetManager002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitNetworkSetManager002 Start"; + try { + int32_t userId = 100; + string bundleName = "com.ohos.ailife"; + NetworkSetManager::InitNetworkSetManager(bundleName, userId); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitNetworkSetManager002 FAILED"; + } + GTEST_LOG_(INFO) << "InitNetworkSetManager002 End"; +} + +/** + * @tc.name: InitNetworkSetManagerTest003 + * @tc.desc: Verify the GetConfigParams function when driveKit is not null. + * @tc.type: FUNC + * @tc.require: ICEGLJ + */ +HWTEST_F(NetworkSetManagerTest, InitNetworkSetManager003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitNetworkSetManager003 Start"; + try { + int32_t userId = 100; + string bundleName = "xxxxxxx"; + NetworkSetManager::InitNetworkSetManager(bundleName, userId); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitNetworkSetManager003 FAILED"; + } + GTEST_LOG_(INFO) << "InitNetworkSetManager003 End"; +} } \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/sync_rule/network_status_test.cpp b/test/unittests/cloudsync_sa/sync_rule/network_status_test.cpp index 1de6389ee4b6b662e287a95348541923eaf647ba..c07770b00754069cf04a2fd94292141ebffb8b73 100644 --- a/test/unittests/cloudsync_sa/sync_rule/network_status_test.cpp +++ b/test/unittests/cloudsync_sa/sync_rule/network_status_test.cpp @@ -26,6 +26,8 @@ #include "utils_log.h" #include "net_conn_client_mock.h" #include "net_handle.h" +#include "settings_data_manager.h" +#include "network_set_manager.h" namespace OHOS::FileManagement::CloudSync::Test { using namespace testing; @@ -356,6 +358,128 @@ HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest004, TestSize.Level1) GTEST_LOG_(INFO) << "CheckMobileNetworkTest End"; } +/** + * @tc.name: CheckMobileNetworkTest005 + * @tc.desc: Verify the CheckMobileNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "com.ohos.ailife"; + int32_t userId = 100; + SettingsDataManager::settingsDataMap_.EnsureInsert("photos_mobile_data_sync", "on"); + bool ret = networkStatus.CheckMobileNetwork(bundleName, userId); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 FAILED"; + } + GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 End"; +} + +/** + * @tc.name: CheckMobileNetworkTest006 + * @tc.desc: Verify the CheckMobileNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMobileNetworkTest006 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "com.ohos.photos"; + int32_t userId = 100; + std::string key = std::to_string(userId) + "/" + bundleName; + NetworkSetManager::cellularNetMap_.EnsureInsert(key, true); + bool ret = networkStatus.CheckMobileNetwork(bundleName, userId); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMobileNetworkTest006 FAILED"; + } + GTEST_LOG_(INFO) << "CheckMobileNetworkTest006 End"; +} + +/** + * @tc.name: CheckMobileNetworkTest007 + * @tc.desc: Verify the CheckMobileNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest007, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMobileNetworkTest007 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "com.ohos.photos"; + int32_t userId = 100; + std::string key = std::to_string(userId) + "/" + bundleName; + networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT); + NetworkSetManager::cellularNetMap_.EnsureInsert(key, false); + bool ret = networkStatus.CheckMobileNetwork(bundleName, userId); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMobileNetworkTest007 FAILED"; + } + GTEST_LOG_(INFO) << "CheckMobileNetworkTest007 End"; +} + +/** + * @tc.name: CheckMobileNetworkTest008 + * @tc.desc: Verify the CheckMobileNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest008, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMobileNetworkTest008 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "com.ohos.photos"; + int32_t userId = 100; + std::string key = std::to_string(userId) + "/" + bundleName; + networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK); + NetworkSetManager::cellularNetMap_.EnsureInsert(key, false); + bool ret = networkStatus.CheckMobileNetwork(bundleName, userId); + EXPECT_EQ(ret, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMobileNetworkTest008 FAILED"; + } + GTEST_LOG_(INFO) << "CheckMobileNetworkTest008 End"; +} + +/** + * @tc.name: CheckMobileNetworkTest009 + * @tc.desc: Verify the CheckMobileNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest009, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckMobileNetworkTest009 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "xxxxxxxxx"; + int32_t userId = 100; + std::string key = std::to_string(userId) + "/" + bundleName; + networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK); + NetworkSetManager::cellularNetMap_.EnsureInsert(key, false); + bool ret = networkStatus.CheckMobileNetwork(bundleName, userId); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckMobileNetworkTest009 FAILED"; + } + GTEST_LOG_(INFO) << "CheckMobileNetworkTest009 End"; +} + /** * @tc.name: CheckNetworkTest001 * @tc.desc: Verify the CheckNetwork function @@ -422,6 +546,52 @@ HWTEST_F(NetworkStatusTest, CheckNetworkTest003, TestSize.Level1) GTEST_LOG_(INFO) << "CheckNetworkTest End"; } +/** + * @tc.name: CheckNetworkTest004 + * @tc.desc: Verify the CheckNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckNetworkTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckNetworkTest004 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "com.ohos.ailife"; + int32_t userId = 100; + SettingsDataManager::settingsDataMap_.EnsureInsert("photos_network_connection_status", "on"); + bool ret = networkStatus.CheckNetwork(bundleName, userId); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckNetworkTest004 FAILED"; + } + GTEST_LOG_(INFO) << "CheckNetworkTest004 End"; +} + +/** + * @tc.name: CheckNetworkTest005 + * @tc.desc: Verify the CheckNetwork function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(NetworkStatusTest, CheckNetworkTest005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "CheckNetworkTest005 Start"; + try { + NetworkStatus networkStatus; + string bundleName = "com.ohos.ailife"; + int32_t userId = 100; + SettingsDataManager::settingsDataMap_.EnsureInsert("photos_network_connection_status", "false"); + bool ret = networkStatus.CheckNetwork(bundleName, userId); + EXPECT_EQ(ret, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "CheckNetworkTest005 FAILED"; + } + GTEST_LOG_(INFO) << "CheckNetworkTest005 End"; +} + /** * @tc.name: OnNetworkAvailTest001 * @tc.desc: Verify the OnNetworkAvail function diff --git a/test/unittests/cloudsync_sa/sync_rule/settings_data_manager_test.cpp b/test/unittests/cloudsync_sa/sync_rule/settings_data_manager_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7dcbbb2b3880f9cea49d10cfddbadd11120dcb7e --- /dev/null +++ b/test/unittests/cloudsync_sa/sync_rule/settings_data_manager_test.cpp @@ -0,0 +1,575 @@ +/* + * 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 +#include +#include + +#include "datashare_helper_mock.h" +#include "datashare_result_set_mock.h" +#include "dfs_error.h" +#include "settings_data_manager.h" + +namespace OHOS::FileManagement::CloudSync::Test { +using namespace testing; +using namespace testing::ext; +using namespace std; +using namespace OHOS::DataShare; + +static const std::string SYNC_SWITCH_KEY = "photos_sync_options"; +static const std::string NETWORK_CONNECTION_KEY = "photos_network_connection_status"; +static const std::string LOCAL_SPACE_FREE_KEY = "photos_local_space_free"; +static const std::string LOCAL_SPACE_DAYS_KEY = "photos_local_space_days"; +static const std::string MOBILE_DATA_SYNC_KEY = "photos_mobile_data_sync"; + +class SettingsDataManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + static inline shared_ptr dataShareHelperMock_ = nullptr; + static inline shared_ptr resultSetMock_ = nullptr; +}; + +void SettingsDataManagerTest::SetUpTestCase(void) +{ + GTEST_LOG_(INFO) << "SetUpTestCase"; + dataShareHelperMock_ = std::make_shared(); + resultSetMock_ = std::make_shared(); + DataShareHelperMock::proxy_ = dataShareHelperMock_; + DataShareResultSetMock::proxy_ = resultSetMock_; +} + +void SettingsDataManagerTest::TearDownTestCase(void) +{ + GTEST_LOG_(INFO) << "TearDownTestCase"; + dataShareHelperMock_ = nullptr; + DataShareHelperMock::proxy_ = nullptr; + resultSetMock_ = nullptr; + DataShareResultSetMock::proxy_ = nullptr; +} + +void SettingsDataManagerTest::SetUp(void) +{ + DataShareHelperMock::proxy_ = dataShareHelperMock_; + DataShareResultSetMock::proxy_ = resultSetMock_; +} + +void SettingsDataManagerTest::TearDown(void) {} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest001 Start"; + DataShareResultSetMock::proxy_ = nullptr; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_RDB); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest002 Start"; + DataShareResultSetMock::proxy_ = nullptr; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_OK); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest003 Start"; + DataShareResultSetMock::proxy_ = nullptr; + std::shared_ptr dataShareHelper = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(nullptr)); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_RDB); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest003 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest004 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK)); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_OK); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest004 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest005 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(-1)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).Times(0); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_INNER_RDB); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest005 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest006 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(-1)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_RDB); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest006 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest007, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest007 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(-1)); + std::string key = ""; + std::string value; + int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value); + EXPECT_EQ(ret, E_RDB); + + GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest007 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache(); + EXPECT_EQ(status, SwitchStatus::NONE); + + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest002 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(-1)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).Times(0); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0); + SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache(); + EXPECT_EQ(status, SwitchStatus::CLOUD_SPACE); + + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest003 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "0"); + SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache(); + EXPECT_EQ(status, SwitchStatus::NONE); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest003 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest004 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "1"); + SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache(); + EXPECT_EQ(status, SwitchStatus::CLOUD_SPACE); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest004 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest005 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "2"); + SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache(); + EXPECT_EQ(status, SwitchStatus::AI_FAMILY); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest005 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest006 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(-1)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0); + SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache(); + EXPECT_EQ(status, SwitchStatus::NONE); + + GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest006 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SwitchStatus status = SettingsDataManager::GetSwitchStatus(); + EXPECT_EQ(status, SwitchStatus::NONE); + + GTEST_LOG_(INFO) << "GetSwitchStatusTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusTest002 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(-1)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).Times(0); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0); + SwitchStatus status = SettingsDataManager::GetSwitchStatus(); + EXPECT_EQ(status, SwitchStatus::CLOUD_SPACE); + + GTEST_LOG_(INFO) << "GetSwitchStatusTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusTest003 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK)); + SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "2"); + SwitchStatus status = SettingsDataManager::GetSwitchStatus(); + EXPECT_EQ(status, SwitchStatus::NONE); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetSwitchStatusTest003 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusTest004 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK)); + SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "1"); + SwitchStatus status = SettingsDataManager::GetSwitchStatus(); + EXPECT_EQ(status, SwitchStatus::NONE); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetSwitchStatusTest004 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatusTest005 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + std::shared_ptr resultSet = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet)); + EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK)); + EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK)); + SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "0"); + SwitchStatus status = SettingsDataManager::GetSwitchStatus(); + EXPECT_EQ(status, SwitchStatus::NONE); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetSwitchStatusTest005 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetNetworkConnectionStatusTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + std::string status = SettingsDataManager::GetNetworkConnectionStatus(); + EXPECT_EQ(status, "on"); + + GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetNetworkConnectionStatusTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest002 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(NETWORK_CONNECTION_KEY, "false"); + std::string status = SettingsDataManager::GetNetworkConnectionStatus(); + EXPECT_EQ(status, "false"); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeStatusTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + std::string status = SettingsDataManager::GetLocalSpaceFreeStatus(); + EXPECT_EQ(status, ""); + + GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeStatusTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest002 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_FREE_KEY, "false"); + std::string status = SettingsDataManager::GetLocalSpaceFreeStatus(); + EXPECT_EQ(status, "false"); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeDaysTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + std::string status = SettingsDataManager::GetLocalSpaceFreeDays(); + EXPECT_EQ(status, ""); + + GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeDaysTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest002 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_DAYS_KEY, "10"); + std::string status = SettingsDataManager::GetLocalSpaceFreeDays(); + EXPECT_EQ(status, "10"); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetMobileDataStatusTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetMobileDataStatusTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + std::string status = SettingsDataManager::GetMobileDataStatus(); + EXPECT_EQ(status, "on"); + + GTEST_LOG_(INFO) << "GetMobileDataStatusTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, GetMobileDataStatusTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetMobileDataStatusTest002 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::settingsDataMap_.EnsureInsert(MOBILE_DATA_SYNC_KEY, "false"); + std::string status = SettingsDataManager::GetMobileDataStatus(); + EXPECT_EQ(status, "false"); + + SettingsDataManager::settingsDataMap_.Clear(); + GTEST_LOG_(INFO) << "GetMobileDataStatusTest002 end"; +} + +HWTEST_F(SettingsDataManagerTest, RegisterObserverTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RegisterObserverTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::RegisterObserver(""); + EXPECT_TRUE(true); + + GTEST_LOG_(INFO) << "RegisterObserverTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, RegisterObserverTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RegisterObserverTest002 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::RegisterObserver(""); + EXPECT_TRUE(true); + + GTEST_LOG_(INFO) << "RegisterObserverTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, RegisterObserverTest003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RegisterObserverTest003 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::RegisterObserver("", nullptr); + EXPECT_TRUE(true); + + GTEST_LOG_(INFO) << "RegisterObserverTest003 End"; +} + +HWTEST_F(SettingsDataManagerTest, RegisterObserverTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RegisterObserverTest004 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::RegisterObserver("", nullptr); + EXPECT_TRUE(true); + + GTEST_LOG_(INFO) << "RegisterObserverTest004 End"; +} + +HWTEST_F(SettingsDataManagerTest, UnregisterObserverTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UnregisterObserverTest001 Start"; + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::UnregisterObserver(""); + EXPECT_TRUE(true); + + GTEST_LOG_(INFO) << "UnregisterObserverTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, UnregisterObserverTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UnregisterObserverTest002 Start"; + std::shared_ptr dataShareHelper = std::make_shared(); + EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper)); + EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0); + SettingsDataManager::UnregisterObserver(""); + EXPECT_TRUE(true); + + GTEST_LOG_(INFO) << "UnregisterObserverTest002 End"; +} + +HWTEST_F(SettingsDataManagerTest, QueryTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "QueryTest001 Start"; + DataShareHelperMock::proxy_ = nullptr; + DataShareResultSetMock::proxy_ = nullptr; + int32_t ret = -1; + int32_t size = -1; + ret = SettingsDataManager::QuerySwitchStatus(); + EXPECT_EQ(ret, E_OK); + size = SettingsDataManager::settingsDataMap_.Size(); + EXPECT_EQ(size, 1); + + ret = SettingsDataManager::QueryNetworkConnectionStatus(); + EXPECT_EQ(ret, E_OK); + size = SettingsDataManager::settingsDataMap_.Size(); + EXPECT_EQ(size, 2); + + ret = SettingsDataManager::QueryLocalSpaceFreeStatus(); + EXPECT_EQ(ret, E_OK); + size = SettingsDataManager::settingsDataMap_.Size(); + EXPECT_EQ(size, 3); + + ret = SettingsDataManager::QueryLocalSpaceFreeDays(); + EXPECT_EQ(ret, E_OK); + size = SettingsDataManager::settingsDataMap_.Size(); + EXPECT_EQ(size, 4); + + ret = SettingsDataManager::QueryMobileDataStatus(); + EXPECT_EQ(ret, E_OK); + size = SettingsDataManager::settingsDataMap_.Size(); + EXPECT_EQ(size, 5); + + GTEST_LOG_(INFO) << "QueryTest001 End"; +} + +HWTEST_F(SettingsDataManagerTest, OnChangeTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnChangeTest001 Start"; + DataShareHelperMock::proxy_ = nullptr; + DataShareResultSetMock::proxy_ = nullptr; + + SettingsDataObserver observer1(SYNC_SWITCH_KEY); + observer1.OnChange(); + + SettingsDataObserver observer2(NETWORK_CONNECTION_KEY); + observer2.OnChange(); + + SettingsDataObserver observer3(LOCAL_SPACE_FREE_KEY); + observer3.OnChange(); + + SettingsDataObserver observer4(LOCAL_SPACE_DAYS_KEY); + observer4.OnChange(); + + SettingsDataObserver observer5(MOBILE_DATA_SYNC_KEY); + observer5.OnChange(); + + GTEST_LOG_(INFO) << "OnChangeTest001 End"; +} +} \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/system/BUILD.gn b/test/unittests/cloudsync_sa/system/BUILD.gn index ee4437027c1b30d0a42c184fcc13c3d471c1d832..f7cbf51e52b9170dcca89fa0fc3cc84ffb439696 100644 --- a/test/unittests/cloudsync_sa/system/BUILD.gn +++ b/test/unittests/cloudsync_sa/system/BUILD.gn @@ -83,6 +83,7 @@ ohos_unittest("dfsu_access_token_helper_test") { "hisysevent:libhisysevent", "image_framework:image_native", "ipc:ipc_core", + "os_account:os_account_innerkits", "preferences:native_preferences", ] diff --git a/test/unittests/cloudsync_sa/system/dfsu_access_token_helper_test.cpp b/test/unittests/cloudsync_sa/system/dfsu_access_token_helper_test.cpp index 32a1e381276155257eed00f9a096b7bd9154aaad..d57ad480d843f332905c710ab01640cf4c4cfba3 100644 --- a/test/unittests/cloudsync_sa/system/dfsu_access_token_helper_test.cpp +++ b/test/unittests/cloudsync_sa/system/dfsu_access_token_helper_test.cpp @@ -208,4 +208,67 @@ HWTEST_F(DfsuAccessTokenHelperTest, GetUserIdTest, TestSize.Level1) GTEST_LOG_(INFO) << "GetUserIdTest End"; } + +/** + * @tc.name: IsUserVerified001 + * @tc.desc: Verify the IsUserVerifyed function + * @tc.type: FUNC + */ +HWTEST_F(DfsuAccessTokenHelperTest, IsUserVerified001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsUserVerified001 Begin"; + try { + int32_t userId = 100; + auto res = DfsuAccessTokenHelper::IsUserVerifyed(userId); + // permission denied + EXPECT_EQ(res, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << " IsUserVerified001 ERROR"; + } + + GTEST_LOG_(INFO) << "IsUserVerified001 End"; +} + +/** + * @tc.name: IsUserVerified002 + * @tc.desc: Verify the IsUserVerifyed function + * @tc.type: FUNC + */ +HWTEST_F(DfsuAccessTokenHelperTest, IsUserVerified002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsUserVerified002 Begin"; + try { + int32_t userId = 10; + auto res = DfsuAccessTokenHelper::IsUserVerifyed(userId); + // permission denied + EXPECT_EQ(res, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << " IsUserVerified002 ERROR"; + } + + GTEST_LOG_(INFO) << "IsUserVerified002 End"; +} + +/** + * @tc.name: GetAccountId001 + * @tc.desc: Verify the GetAccountId function + * @tc.type: FUNC + */ +HWTEST_F(DfsuAccessTokenHelperTest, GetAccountId001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetAccountId001 Begin"; + try { + int32_t userId = 0; + auto res = DfsuAccessTokenHelper::GetAccountId(userId); + // permission denied + EXPECT_NE(res, 0); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << " GetAccountId001 ERROR"; + } + + GTEST_LOG_(INFO) << "GetAccountId001 End"; +} } // namespace OHOS::FileManagement::Test diff --git a/test/unittests/services_daemon/BUILD.gn b/test/unittests/services_daemon/BUILD.gn index 6a7e0a1b48a99c65c1bb2cc2779f9a47fd715b8b..b1027033c5b9cd7b8b5814bd52f4f6c315c49ea2 100644 --- a/test/unittests/services_daemon/BUILD.gn +++ b/test/unittests/services_daemon/BUILD.gn @@ -20,6 +20,7 @@ ohos_unittest("fuse_manager_test") { sources = [ "${distributedfile_path}/services/cloudfiledaemon/src/fuse_manager/cloud_daemon_statistic.cpp", "${distributedfile_path}/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp", + "${services_path}/cloudfiledaemon/src/utils/setting_data_helper.cpp", "fuse_manager_test.cpp", "mock/libfuse_mock.cpp", "mock/system_function_mock.cpp", @@ -41,6 +42,7 @@ ohos_unittest("fuse_manager_test") { "${distributedfile_path}/services/cloudfiledaemon/include/fuse_manager", "${distributedfile_path}/utils/ioctl/include", "${services_path}/cloudfiledaemon/include/cloud_disk/", + "${services_path}/cloudfiledaemon/include/utils/", "${services_path}/cloudfiledaemon/src/fuse_manager", "${distributedfile_path}/adapter/cloud_adapter_example/include", "${clouddisk_database_path}/include", @@ -61,6 +63,7 @@ ohos_unittest("fuse_manager_test") { "ability_runtime:dataobs_manager", "bounds_checking_function:libsec_shared", "c_utils:utils", + "data_share:datashare_consumer", "ffrt:libffrt", "googletest:gmock_main", "googletest:gtest_main", @@ -234,6 +237,7 @@ ohos_unittest("cloud_daemon_test") { "${distributedfile_path}/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp", "${distributedfile_path}/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp", "${distributedfile_path}/services/cloudfiledaemon/src/ipc/cloud_daemon_stub.cpp", + "${services_path}/cloudfiledaemon/src/utils/setting_data_helper.cpp", "cloud_daemon_test.cpp", "mock/system_function_mock.cpp", ] @@ -271,6 +275,7 @@ ohos_unittest("cloud_daemon_test") { "${innerkits_native_path}/cloud_file_kit_inner/big_data_statistics", "${services_path}/cloudfiledaemon/include/fuse_manager/", "${services_path}/cloudfiledaemon/include/ipc/", + "${services_path}/cloudfiledaemon/include/utils/", "${services_path}/cloudsyncservice/include/data_sync/", ] @@ -288,6 +293,7 @@ ohos_unittest("cloud_daemon_test") { "ability_runtime:dataobs_manager", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "data_share:datashare_consumer", "ffrt:libffrt", "googletest:gmock_main", "googletest:gtest_main", @@ -320,6 +326,101 @@ ohos_unittest("cloud_daemon_test") { subsystem_name = "filemanagement" } +ohos_unittest("cloud_daemon_nomock_test") { + module_out_path = "dfs_service/dfs_service" + + sources = [ + "${distributedfile_path}/services/cloudfiledaemon/src/fuse_manager/cloud_daemon_statistic.cpp", + "${distributedfile_path}/services/cloudfiledaemon/src/fuse_manager/fuse_manager.cpp", + "${distributedfile_path}/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp", + "${distributedfile_path}/services/cloudfiledaemon/src/ipc/cloud_daemon_stub.cpp", + "${services_path}/cloudfiledaemon/src/utils/setting_data_helper.cpp", + "cloud_daemon_nomock_test.cpp", + ] + + cloud_disk = [ + "${services_path}/cloudfiledaemon/src/cloud_disk/database_manager.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/file_operations_base.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/file_operations_cloud.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/file_operations_local.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/fuse_operations.cpp", + "${distributedfile_path}/services/cloudfiledaemon/src/cloud_disk/file_operations_helper.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/account_status.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/account_status_listener.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/appstate_observer.cpp", + "${services_path}/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp", + ] + + sources += cloud_disk + + include_dirs = [ + "${distributedfile_path}/services/cloudfiledaemon/include", + "${services_path}/cloudfiledaemon/include/cloud_disk/", + "${distributedfile_path}/adapter/cloud_adapter_example/include", + "${clouddisk_database_path}/include", + "${distributedfile_path}/test/unittests/services_daemon/mock", + "${distributedfile_path}/services/cloudfiledaemon/include/fuse_manager", + "${distributedfile_path}/interfaces/inner_api/native", + "${distributedfile_path}/interfaces/inner_api/native/cloud_file_kit_inner/big_data_statistics", + "${distributedfile_path}/utils/ioctl/include", + "${utils_path}/cloud_disk/include", + "${utils_path}/dentry/include", + "${utils_path}/log/include", + "${utils_path}/system/include", + "${innerkits_native_path}/cloud_daemon_kit_inner", + "${innerkits_native_path}/cloud_file_kit_inner/big_data_statistics", + "${services_path}/cloudfiledaemon/include/fuse_manager/", + "${services_path}/cloudfiledaemon/include/ipc/", + "${services_path}/cloudfiledaemon/include/utils/", + "${services_path}/cloudsyncservice/include/data_sync/", + ] + + deps = [ + "${clouddisk_database_path}:clouddisk_database", + "${innerkits_native_path}/cloud_daemon_kit_inner:cloud_daemon_kit_inner", + "${innerkits_native_path}/cloud_file_kit_inner:cloudfile_kit_core", + "${utils_path}:libdistributedfiledentry", + "${utils_path}:libdistributedfileutils", + "${utils_path}:libdistributedfileutils_lite", + ] + + external_deps = [ + "ability_base:zuri", + "ability_runtime:dataobs_manager", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "data_share:datashare_consumer", + "ffrt:libffrt", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "hisysevent:libhisysevent", + "hitrace:hitrace_meter", + "init:libbegetutil", + "ipc:ipc_single", + "libfuse:libfuse", + "relational_store:native_rdb", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "ability_runtime:app_manager", + ] + + defines = [ + "private=public", + "LOG_DOMAIN=0xD004308", + "LOG_TAG=\"CloudFileDaemon\"", + ] + + if (cloudsync_service_hicollie_enable) { + external_deps += [ "hicollie:libhicollie" ] + defines += [ "HICOLLIE_ENABLE" ] + } + + use_exceptions = true + part_name = "dfs_service" + subsystem_name = "filemanagement" +} + ohos_unittest("cloud_daemon_stub_test") { module_out_path = "dfs_service/dfs_service" @@ -437,6 +538,72 @@ ohos_unittest("fuse_manager_static_test") { subsystem_name = "filemanagement" } +ohos_unittest("setting_data_helper_test") { + module_out_path = "dfs_service/dfs_service" + + sources = [ + "${services_path}/cloudfiledaemon/src/utils/setting_data_helper.cpp", + "mock/data_helper_mock.cpp", + "setting_data_helper_test.cpp", + ] + + include_dirs = [ + "${clouddisk_database_path}/include", + "${distributedfile_path}/interfaces/inner_api/native/cloudsync_kit_inner", + "${distributedfile_path}/services/cloudfiledaemon/include", + "${distributedfile_path}/services/cloudfiledaemon/include/cloud_disk", + "${distributedfile_path}/services/cloudfiledaemon/include/fuse_manager", + "${distributedfile_path}/services/cloudfiledaemon/include/utils", + "${innerkits_native_path}/cloud_daemon_kit_inner", + "${innerkits_native_path}/cloud_file_kit_inner", + "${innerkits_native_path}/cloud_file_kit_inner/big_data_statistics", + "${services_path}/cloudfiledaemon/include/ipc/", + "${services_path}/cloudfiledaemon/src/fuse_manager", + "${services_path}/cloudsyncservice/include/data_sync/", + "${utils_path}/cloud_disk/include", + "${utils_path}/dentry/include", + "${utils_path}/log/include", + "mock" + ] + + deps = [ + "${utils_path}:libdistributedfileutils_lite", + ] + + external_deps = [ + "ability_base:zuri", + "ability_runtime:dataobs_manager", + "bounds_checking_function:libsec_shared", + "c_utils:utils", + "data_share:datashare_consumer", + "ffrt:libffrt", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "hisysevent:libhisysevent", + "hitrace:hitrace_meter", + "init:libbegetutil", + "ipc:ipc_single", + "libfuse:libfuse", + "relational_store:native_rdb", + ] + + defines = [ + "private=public", + "LOG_DOMAIN=0xD004308", + "LOG_TAG=\"SettingDataHelperTest\"", + ] + + if (cloudsync_service_hicollie_enable) { + external_deps += [ "hicollie:libhicollie" ] + defines += [ "HICOLLIE_ENABLE" ] + } + + use_exceptions = true + part_name = "dfs_service" + subsystem_name = "filemanagement" +} + group("services_daemon_test") { testonly = true @@ -447,5 +614,7 @@ group("services_daemon_test") { ":cloud_daemon_test", ":fuse_manager_test", ":fuse_manager_static_test", + ":setting_data_helper_test", + ":cloud_daemon_nomock_test", ] } diff --git a/test/unittests/services_daemon/cloud_daemon_nomock_test.cpp b/test/unittests/services_daemon/cloud_daemon_nomock_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e2b57ddde98ff66a27d66b07a838bd7fb5f01d35 --- /dev/null +++ b/test/unittests/services_daemon/cloud_daemon_nomock_test.cpp @@ -0,0 +1,105 @@ +/* + * 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 "dfs_error.h" +#include "fuse_assistant.h" +#include "fuse_manager/fuse_manager.h" +#include "ipc/cloud_daemon.h" +#include "iremote_object.h" +#include "setting_data_helper.h" +#include "system_ability_definition.h" +#include "utils_log.h" + +namespace OHOS::FileManagement::CloudFile::Test { +using namespace testing; +using namespace testing::ext; +constexpr int32_t USER_ID = 100; +constexpr int32_t DEV_FD = 10; + +class CloudDaemonTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + std::shared_ptr cloudDaemon_; +}; + +void CloudDaemonTest::SetUpTestCase(void) +{ + GTEST_LOG_(INFO) << "SetUpTestCase"; +} + +void CloudDaemonTest::TearDownTestCase(void) +{ + GTEST_LOG_(INFO) << "TearDownTestCase"; +} + +void CloudDaemonTest::SetUp(void) +{ + int32_t saID = FILEMANAGEMENT_CLOUD_DAEMON_SERVICE_SA_ID; + bool runOnCreate = true; + cloudDaemon_ = std::make_shared(saID, runOnCreate); + GTEST_LOG_(INFO) << "SetUp"; +} + +void CloudDaemonTest::TearDown(void) +{ + GTEST_LOG_(INFO) << "TearDown"; +} + +/** + * @tc.name: OnAddSystemAbilityTest001 + * @tc.desc: Verify the OnStart function + * @tc.type: FUNC + * @tc.require: issuesIB538J + */ +HWTEST_F(CloudDaemonTest, OnAddSystemAbility001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnAddSystemAbility001 start"; + try { + const int32_t systemAbilityId = 100; + const std::string deviceId = "device_test"; + cloudDaemon_->OnAddSystemAbility(systemAbilityId, deviceId); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest001 failed"; + } + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest001 end"; +} + +/** + * @tc.name: OnAddSystemAbilityTest002 + * @tc.desc: Verify the OnAddSystemAbility function + * @tc.type: FUNC + */ +HWTEST_F(CloudDaemonTest, OnAddSystemAbilityTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 start"; + try { + const int32_t systemAbilityId = DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID; + const std::string deviceId = "device_test"; + SettingDataHelper::GetInstance().isBundleInited_ = true; + cloudDaemon_->OnAddSystemAbility(systemAbilityId, deviceId); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 failed"; + } + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 end"; +} +} // namespace OHOS::FileManagement::CloudSync::Test \ No newline at end of file diff --git a/test/unittests/services_daemon/cloud_daemon_test.cpp b/test/unittests/services_daemon/cloud_daemon_test.cpp index 1525544778a6d4bc3786551685c5146831df844b..b102f0aebefb6ab5fbf0c203081dc0a71f158039 100644 --- a/test/unittests/services_daemon/cloud_daemon_test.cpp +++ b/test/unittests/services_daemon/cloud_daemon_test.cpp @@ -21,6 +21,7 @@ #include "fuse_manager/fuse_manager.h" #include "ipc/cloud_daemon.h" #include "iremote_object.h" +#include "setting_data_helper.h" #include "system_ability_definition.h" #include "utils_log.h" @@ -256,4 +257,24 @@ HWTEST_F(CloudDaemonTest, OnAddSystemAbility001, TestSize.Level1) } GTEST_LOG_(INFO) << "OnAddSystemAbilityTest001 end"; } + +/** + * @tc.name: OnAddSystemAbilityTest002 + * @tc.desc: Verify the OnAddSystemAbility function + * @tc.type: FUNC + */ +HWTEST_F(CloudDaemonTest, OnAddSystemAbilityTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 start"; + try { + const int32_t systemAbilityId = DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID; + const std::string deviceId = "device_test"; + SettingDataHelper::GetInstance().isBundleInited_ = true; + cloudDaemon_->OnAddSystemAbility(systemAbilityId, deviceId); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 failed"; + } + GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 end"; +} } // namespace OHOS::FileManagement::CloudSync::Test \ No newline at end of file diff --git a/test/unittests/services_daemon/fuse_manager_static_test.cpp b/test/unittests/services_daemon/fuse_manager_static_test.cpp index 446d88dbbc56518091dc94e05d8e6103a6789bb8..a7c718843e57b918e4bd34f54e6211f8fc0250a3 100644 --- a/test/unittests/services_daemon/fuse_manager_static_test.cpp +++ b/test/unittests/services_daemon/fuse_manager_static_test.cpp @@ -372,4 +372,46 @@ HWTEST_F(FuseManagerStaticTest, DeleteFdsanTest003, TestSize.Level1) } GTEST_LOG_(INFO) << "DeleteFdsanTest003 end"; } + +/** + * @tc.name: IsHdc001 + * @tc.desc: Verify the IsHdc function + * @tc.type: FUNC + */ +HWTEST_F(FuseManagerStaticTest, IsHdc001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsHdc001 Begin"; + try { + struct FuseData data; + data.activeBundle = CloudSync::GALLERY_BUNDLE_NAME; + bool ret = IsHdc(&data); + + EXPECT_EQ(ret, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IsHdc001 Error"; + } + GTEST_LOG_(INFO) << "IsHdc001 End"; +} + +/** + * @tc.name: IsHdc002 + * @tc.desc: Verify the IsHdc function + * @tc.type: FUNC + */ +HWTEST_F(FuseManagerStaticTest, IsHdc002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsHdc002 Begin"; + try { + struct FuseData data; + data.activeBundle = CloudSync::HDC_BUNDLE_NAME; + bool ret = IsHdc(&data); + + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IsHdc002 Error"; + } + GTEST_LOG_(INFO) << "IsHdc002 End"; +} } // namespace OHOS::FileManagement::CloudSync::Test \ No newline at end of file diff --git a/test/unittests/services_daemon/mock/data_helper_mock.cpp b/test/unittests/services_daemon/mock/data_helper_mock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8c2bfc79c75f56ef8c643425e3b2b86dc5cb4440 --- /dev/null +++ b/test/unittests/services_daemon/mock/data_helper_mock.cpp @@ -0,0 +1,46 @@ +/* + * 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 "data_helper_mock.h" + +namespace OHOS::DataShare { +using namespace OHOS::FileManagement::CloudFile; +std::shared_ptr DataShareHelper::Creator(const std::string &strUri, + const CreateOptions &options, + const std::string &bundleName, + const int waitTime, + bool isSystem) +{ + return IDataHelper::ins->Creator(); +} +} // namespace OHOS::DataShare + +namespace OHOS::FileManagement::CloudSync { +using namespace OHOS::FileManagement::CloudFile; + +SwitchStatus SettingsDataManager::GetSwitchStatus() +{ + return IDataHelper::ins->GetSwitchStatus(); +} + +int32_t SettingsDataManager::QuerySwitchStatus() +{ + return IDataHelper::ins->QuerySwitchStatus(); +} + +void SettingsDataManager::RegisterObserver(const std::string &key, sptr dataObserver) +{ + return; +} +} // namespace OHOS::FileManagement::CloudSync \ No newline at end of file diff --git a/test/unittests/services_daemon/mock/data_helper_mock.h b/test/unittests/services_daemon/mock/data_helper_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..87afdd7df869f7a2c0db04c7bacd2bcaec641c4b --- /dev/null +++ b/test/unittests/services_daemon/mock/data_helper_mock.h @@ -0,0 +1,115 @@ +/* + * 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 DATA_HELPER_MOCK_H +#define DATA_HELPER_MOCK_H +#include +#include +#include + +#include "datashare_helper.h" +#include "settings_data_manager.h" + +namespace OHOS::FileManagement::CloudFile { +using namespace OHOS::DataShare; +using namespace OHOS::FileManagement::CloudSync; + +class DataShareHelperMock : public DataShareHelper { +public: + MOCK_METHOD5(Creator, + std::shared_ptr(const std::string &strUri, + const CreateOptions &options, + const std::string &bundleName, + const int waitTime, + bool isSystem)); + MOCK_METHOD0(Release, bool()); + MOCK_METHOD2(GetFileTypes, std::vector(Uri &uri, const std::string &mimeTypeFilter)); + MOCK_METHOD2(OpenFile, int(Uri &uri, const std::string &mode)); + MOCK_METHOD3(OpenFileWithErrCode, int(Uri &uri, const std::string &mode, int32_t &errCode)); + MOCK_METHOD2(OpenRawFile, int(Uri &uri, const std::string &mode)); + MOCK_METHOD2(Insert, int(Uri &uri, const DataShareValuesBucket &value)); + MOCK_METHOD3(InsertExt, int(Uri &uri, const DataShareValuesBucket &value, std::string &result)); + MOCK_METHOD3(Update, int(Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value)); + MOCK_METHOD2(BatchUpdate, int(const UpdateOperations &operations, std::vector &results)); + MOCK_METHOD2(Delete, int(Uri &uri, const DataSharePredicates &predicates)); + MOCK_METHOD4(Query, + std::shared_ptr(Uri &uri, + const DataSharePredicates &predicates, + std::vector &columns, + DatashareBusinessError *businessError)); + MOCK_METHOD1(GetType, std::string(Uri &uri)); + MOCK_METHOD2(BatchInsert, int(Uri &uri, const std::vector &values)); + MOCK_METHOD2(ExecuteBatch, int(const std::vector &statements, ExecResultSet &result)); + MOCK_METHOD2(RegisterObserver, int(const Uri &uri, const sptr &dataObserver)); + MOCK_METHOD2(UnregisterObserver, int(const Uri &uri, const sptr &dataObserver)); + MOCK_METHOD1(NotifyChange, void(const Uri &uri)); + MOCK_METHOD3(RegisterObserverExtProvider, + int(const Uri &uri, std::shared_ptr dataObserver, bool isDescendants)); + MOCK_METHOD2(UnregisterObserverExtProvider, int(const Uri &uri, std::shared_ptr dataObserver)); + MOCK_METHOD1(NotifyChangeExtProvider, void(const DataShareObserver::ChangeInfo &changeInfo)); + MOCK_METHOD1(NormalizeUri, Uri(Uri &uri)); + MOCK_METHOD1(DenormalizeUri, Uri(Uri &uri)); + MOCK_METHOD3(AddQueryTemplate, int(const std::string &uri, int64_t subscriberId, Template &tpl)); + MOCK_METHOD2(DelQueryTemplate, int(const std::string &uri, int64_t subscriberId)); + MOCK_METHOD2(Publish, std::vector(const Data &data, const std::string &bundleName)); + MOCK_METHOD2(GetPublishedData, Data(const std::string &bundleName, int &resultCode)); + MOCK_METHOD3(SubscribeRdbData, + std::vector(const std::vector &uris, + const TemplateId &templateId, + const std::function &callback)); + MOCK_METHOD2(UnsubscribeRdbData, + std::vector(const std::vector &uris, const TemplateId &templateId)); + MOCK_METHOD2(EnableRdbSubs, + std::vector(const std::vector &uris, const TemplateId &templateId)); + MOCK_METHOD2(DisableRdbSubs, + std::vector(const std::vector &uris, const TemplateId &templateId)); + MOCK_METHOD3( + SubscribePublishedData, + std::vector(const std::vector &uris, + int64_t subscriberId, + const std::function &callback)); + MOCK_METHOD2(UnsubscribePublishedData, + std::vector(const std::vector &uris, int64_t subscriberId)); + MOCK_METHOD2(EnablePubSubs, + std::vector(const std::vector &uris, int64_t subscriberId)); + MOCK_METHOD2(DisablePubSubs, + std::vector(const std::vector &uris, int64_t subscriberId)); + MOCK_METHOD2(InsertEx, std::pair(Uri &uri, const DataShareValuesBucket &value)); + MOCK_METHOD3(UpdateEx, + std::pair(Uri &uri, + const DataSharePredicates &predicates, + const DataShareValuesBucket &value)); + MOCK_METHOD2(DeleteEx, std::pair(Uri &uri, const DataSharePredicates &predicates)); + MOCK_METHOD3(UserDefineFunc, int32_t(MessageParcel &data, MessageParcel &reply, MessageOption &option)); +}; + +class IDataHelper { +public: + virtual ~IDataHelper() = default; + virtual std::shared_ptr Creator() = 0; + virtual SwitchStatus GetSwitchStatus() = 0; + virtual int32_t QuerySwitchStatus() = 0; + +public: + static inline std::shared_ptr ins = nullptr; +}; + +class DataHelperMock : public IDataHelper { +public: + MOCK_METHOD0(Creator, std::shared_ptr()); + MOCK_METHOD0(GetSwitchStatus, SwitchStatus()); + MOCK_METHOD0(QuerySwitchStatus, int32_t()); +}; +} // namespace OHOS::FileManagement::CloudFile +#endif \ No newline at end of file diff --git a/test/unittests/services_daemon/setting_data_helper_test.cpp b/test/unittests/services_daemon/setting_data_helper_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6c85941bae6b55ca6eaf97296081d7099275fbae --- /dev/null +++ b/test/unittests/services_daemon/setting_data_helper_test.cpp @@ -0,0 +1,382 @@ +/* + * 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 "fuse_manager.cpp" + +#include "data_helper_mock.h" +#include "data_sync_const.h" +#include "dfs_error.h" +#include "setting_data_helper.h" + +namespace OHOS::FileManagement::CloudFile { +using namespace std; +using namespace testing; +using namespace testing::ext; +using namespace OHOS::DataShare; + +class SettingDataHelperTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + static inline shared_ptr mock_ = nullptr; +}; + +void SettingDataHelperTest::SetUpTestCase(void) +{ + GTEST_LOG_(INFO) << "SetUpTestCase"; +} + +void SettingDataHelperTest::TearDownTestCase(void) +{ + GTEST_LOG_(INFO) << "TearDownTestCase"; +} + +void SettingDataHelperTest::SetUp(void) +{ + GTEST_LOG_(INFO) << "SetUp"; + mock_ = make_shared(); + DataHelperMock::ins = mock_; +} + +void SettingDataHelperTest::TearDown(void) +{ + GTEST_LOG_(INFO) << "TearDown"; + DataHelperMock::ins = nullptr; + mock_ = nullptr; +} + +/** + * @tc.name: GetInstanceTest + * @tc.desc: Verify the GetInstance function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, GetInstanceTest, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetInstanceTest start"; + try { + SettingDataHelper::GetInstance(); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "GetInstanceTest failed"; + } + GTEST_LOG_(INFO) << "GetInstanceTest end"; +} + +/** + * @tc.name: SetUserDataTest + * @tc.desc: Verify the SetUserData function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, SetUserDataTest, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SetUserDataTest start"; + try { + SettingDataHelper::GetInstance().SetUserData(nullptr); + EXPECT_EQ(SettingDataHelper::GetInstance().data_, nullptr); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SetUserDataTest failed"; + } + GTEST_LOG_(INFO) << "SetUserDataTest end"; +} + + +/** + * @tc.name: IsDataShareReadyTest001 + * @tc.desc: Verify the IsDataShareReady function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, IsDataShareReadyTest001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsDataShareReadyTest001 start"; + try { + SettingDataHelper::GetInstance().isDataShareReady_ = true; + bool ret = SettingDataHelper::GetInstance().IsDataShareReady(); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IsDataShareReadyTest001 failed"; + } + GTEST_LOG_(INFO) << "IsDataShareReadyTest001 end"; +} + +/** + * @tc.name: IsDataShareReadyTest002 + * @tc.desc: Verify the IsDataShareReady function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, IsDataShareReadyTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsDataShareReadyTest002 start"; + try { + EXPECT_CALL(*mock_, Creator()).WillOnce(Return(nullptr)); + SettingDataHelper::GetInstance().isDataShareReady_ = false; + bool ret = SettingDataHelper::GetInstance().IsDataShareReady(); + EXPECT_EQ(ret, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IsDataShareReadyTest002 failed"; + } + GTEST_LOG_(INFO) << "IsDataShareReadyTest002 end"; +} + +/** + * @tc.name: IsDataShareReadyTest003 + * @tc.desc: Verify the IsDataShareReady function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, IsDataShareReadyTest003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsDataShareReadyTest003 start"; + try { + shared_ptr helper = std::make_shared();; + EXPECT_CALL(*helper, Release()).WillOnce(Return(true)); + EXPECT_CALL(*mock_, Creator()).WillOnce(Return(helper)); + SettingDataHelper::GetInstance().isDataShareReady_ = false; + bool ret = SettingDataHelper::GetInstance().IsDataShareReady(); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IsDataShareReadyTest003 failed"; + } + GTEST_LOG_(INFO) << "IsDataShareReadyTest003 end"; +} + +/** + * @tc.name: GetSwitchStatus001 + * @tc.desc: Verify the GetSwitchStatus function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, GetSwitchStatus001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatus001 start"; + try { + EXPECT_CALL(*mock_, GetSwitchStatus()).WillOnce(Return(AI_FAMILY)); + string bundle = SettingDataHelper::GetInstance().GetActiveBundle(); + EXPECT_EQ(bundle, HDC_BUNDLE_NAME); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "GetSwitchStatus001 failed"; + } + GTEST_LOG_(INFO) << "GetSwitchStatus001 end"; +} + +/** + * @tc.name: GetSwitchStatus002 + * @tc.desc: Verify the GetSwitchStatus function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, GetSwitchStatus002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatus002 start"; + try { + EXPECT_CALL(*mock_, GetSwitchStatus()).WillOnce(Return(CLOUD_SPACE)); + string bundle = SettingDataHelper::GetInstance().GetActiveBundle(); + EXPECT_EQ(bundle, GALLERY_BUNDLE_NAME); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "GetSwitchStatus002 failed"; + } + GTEST_LOG_(INFO) << "GetSwitchStatus002 end"; +} + +/** + * @tc.name: GetSwitchStatus003 + * @tc.desc: Verify the GetSwitchStatus function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, GetSwitchStatus003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetSwitchStatus003 start"; + try { + EXPECT_CALL(*mock_, GetSwitchStatus()).WillOnce(Return(SwitchStatus::NONE)); + string bundle = SettingDataHelper::GetInstance().GetActiveBundle(); + EXPECT_EQ(bundle, ""); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "GetSwitchStatus003 failed"; + } + GTEST_LOG_(INFO) << "GetSwitchStatus003 end"; +} + +/** + * @tc.name: InitActiveBundle001 + * @tc.desc: Verify the InitActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, InitActiveBundle001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitActiveBundle001 start"; + try { + SettingDataHelper::GetInstance().isBundleInited_ = true; + bool ret = SettingDataHelper::GetInstance().InitActiveBundle(); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitActiveBundle001 failed"; + } + GTEST_LOG_(INFO) << "InitActiveBundle001 end"; +} + +/** + * @tc.name: InitActiveBundle002 + * @tc.desc: Verify the InitActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, InitActiveBundle002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitActiveBundle002 start"; + try { + SettingDataHelper::GetInstance().isBundleInited_ = false; + SettingDataHelper::GetInstance().isDataShareReady_ = false; + + EXPECT_CALL(*mock_, Creator()).WillOnce(Return(nullptr)); + + bool ret = SettingDataHelper::GetInstance().InitActiveBundle(); + EXPECT_EQ(ret, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitActiveBundle002 failed"; + } + GTEST_LOG_(INFO) << "InitActiveBundle002 end"; +} + +/** + * @tc.name: InitActiveBundle003 + * @tc.desc: Verify the InitActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, InitActiveBundle003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitActiveBundle003 start"; + try { + SettingDataHelper::GetInstance().isBundleInited_ = false; + SettingDataHelper::GetInstance().isDataShareReady_ = false; + + shared_ptr helper = std::make_shared(); + EXPECT_CALL(*helper, Release()).WillOnce(Return(true)); + EXPECT_CALL(*mock_, Creator()).WillOnce(Return(helper)); + EXPECT_CALL(*mock_, QuerySwitchStatus()).WillOnce(Return(E_OK)); + EXPECT_CALL(*mock_, GetSwitchStatus()).WillOnce(Return(CLOUD_SPACE)); + + bool ret = SettingDataHelper::GetInstance().InitActiveBundle(); + EXPECT_EQ(ret, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitActiveBundle003 failed"; + } + GTEST_LOG_(INFO) << "InitActiveBundle003 end"; +} + +/** + * @tc.name: UpdateActiveBundle001 + * @tc.desc: Verify the UpdateActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, UpdateActiveBundle001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UpdateActiveBundle001 start"; + try { + EXPECT_CALL(*mock_, QuerySwitchStatus()).WillOnce(Return(E_OK)); + EXPECT_CALL(*mock_, GetSwitchStatus()).WillOnce(Return(CLOUD_SPACE)); + + SettingDataHelper::GetInstance().UpdateActiveBundle(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UpdateActiveBundle001 failed"; + } + GTEST_LOG_(INFO) << "UpdateActiveBundle001 end"; +} + +/** + * @tc.name: RegisterObserver001 + * @tc.desc: Verify the RegisterObserver function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, RegisterObserver001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RegisterObserver001 start"; + try { + SettingDataHelper::GetInstance().RegisterObserver(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "RegisterObserver001 failed"; + } + GTEST_LOG_(INFO) << "RegisterObserver001 end"; +} + +/** + * @tc.name: SetActiveBundle001 + * @tc.desc: Verify the SetActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, SetActiveBundle001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SetActiveBundle001 start"; + try { + SettingDataHelper::GetInstance().data_ = nullptr; + SettingDataHelper::GetInstance().SetActiveBundle(GALLERY_BUNDLE_NAME); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SetActiveBundle001 failed"; + } + GTEST_LOG_(INFO) << "SetActiveBundle001 end"; +} + +/** + * @tc.name: SetActiveBundle002 + * @tc.desc: Verify the SetActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, SetActiveBundle002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SetActiveBundle002 start"; + try { + struct FuseData data; + data.activeBundle = GALLERY_BUNDLE_NAME; + SettingDataHelper::GetInstance().data_ = &data; + SettingDataHelper::GetInstance().SetActiveBundle(HDC_BUNDLE_NAME); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SetActiveBundle002 failed"; + } + GTEST_LOG_(INFO) << "SetActiveBundle002 end"; +} + +/** + * @tc.name: SetActiveBundle003 + * @tc.desc: Verify the SetActiveBundle function + * @tc.type: FUNC + */ +HWTEST_F(SettingDataHelperTest, SetActiveBundle003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SetActiveBundle003 start"; + try { + struct FuseData data; + data.activeBundle = GALLERY_BUNDLE_NAME; + SettingDataHelper::GetInstance().data_ = &data; + SettingDataHelper::GetInstance().SetActiveBundle(GALLERY_BUNDLE_NAME); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SetActiveBundle003 failed"; + } + GTEST_LOG_(INFO) << "SetActiveBundle003 end"; +} +} // namespace OHOS::FileManagement::CloudFile \ No newline at end of file diff --git a/utils/BUILD.gn b/utils/BUILD.gn index dfad5dc11f696cc412cdf2ef0903944d027db64c..3ebce9993cc817d7258c278e54296e0fa4c332cb 100755 --- a/utils/BUILD.gn +++ b/utils/BUILD.gn @@ -130,6 +130,7 @@ ohos_shared_library("libdistributedfileutils") { "ipc:ipc_core", "json:nlohmann_json_static", "napi:ace_napi", + "os_account:os_account_innerkits", "preferences:native_preferences", ] diff --git a/utils/dentry/include/meta_file.h b/utils/dentry/include/meta_file.h index f1476dfb6c09ad5fbd9920b43e710d3f1d7a6aa6..beddc82fc07299027dacd4b539fb9bc77f4851a6 100644 --- a/utils/dentry/include/meta_file.h +++ b/utils/dentry/include/meta_file.h @@ -135,8 +135,8 @@ class MetaFileMgr { public: static MetaFileMgr& GetInstance(); /* recordId is hex string of 256 bits, convert to u8 cloudId[32] to kernel */ - static std::string RecordIdToCloudId(const std::string hexStr); - static std::string CloudIdToRecordId(const std::string cloudId); + static std::string RecordIdToCloudId(const std::string hexStr, bool isHdc = false); + static std::string CloudIdToRecordId(const std::string cloudId, bool isHdc = false); std::shared_ptr GetMetaFile(uint32_t userId, const std::string &path); std::shared_ptr GetCloudDiskMetaFile(uint32_t userId, const std::string &bundleName, const std::string &cloudId); diff --git a/utils/dentry/src/meta_file.cpp b/utils/dentry/src/meta_file.cpp index 0820e0fa3ae603e2122fc530fb2923eb3a1419fd..c8d3c11b07deb7ce10046ccdb9bac5e2fc403fd3 100644 --- a/utils/dentry/src/meta_file.cpp +++ b/utils/dentry/src/meta_file.cpp @@ -45,6 +45,9 @@ constexpr uint32_t BUCKET_BLOCKS = 2; constexpr uint32_t BITS_PER_BYTE = 8; constexpr uint32_t HMDFS_SLOT_LEN_BITS = 3; constexpr uint32_t DIR_SIZE = 4096; +constexpr uint32_t EVEN_NUM_FLAG = 2; +const char HDC_ID_START = '0'; +const std::string HDC_ID_END = "ff"; #pragma pack(push, 1) struct HmdfsDentry { @@ -293,6 +296,7 @@ static bool UpdateDentry(HmdfsDentryGroup &d, const MetaBase &base, uint32_t nam de->fileType = base.fileType; de->size = base.size; de->mode = base.mode; + (void)memset_s(de->recordId, CLOUD_RECORD_ID_LEN, 0, CLOUD_RECORD_ID_LEN); ret = memcpy_s(de->recordId, CLOUD_RECORD_ID_LEN, base.cloudId.c_str(), base.cloudId.length()); if (ret != EOK) { LOGE("memcpy_s failed, dstLen = %{public}d, srcLen = %{public}zu", CLOUD_RECORD_ID_LEN, base.cloudId.length()); @@ -704,18 +708,26 @@ void MetaFileMgr::ClearAll() metaFileList_.clear(); } -std::string MetaFileMgr::RecordIdToCloudId(const std::string hexStr) +std::string MetaFileMgr::RecordIdToCloudId(const std::string hexStr, bool isHdc) { + std::string srcStr = hexStr; + if (isHdc) { + if (srcStr.size() % EVEN_NUM_FLAG != 0) { + srcStr = HDC_ID_START + srcStr + HDC_ID_END; + } else { + srcStr = srcStr + HDC_ID_END; + } + } std::string result; constexpr std::size_t offset = 2; constexpr int changeBase = 16; - for (std::size_t i = 0; i < hexStr.length(); i += offset) { - std::string hexByte = hexStr.substr(i, offset); + for (std::size_t i = 0; i < srcStr.length(); i += offset) { + std::string hexByte = srcStr.substr(i, offset); char *endPtr; unsigned long hexValue = std::strtoul(hexByte.c_str(), &endPtr, changeBase); if (endPtr != hexByte.c_str() + hexByte.length()) { - LOGE("Invalid hexadecimal string: %{public}s", hexStr.c_str()); + LOGE("Invalid hexadecimal string: %{public}s", srcStr.c_str()); return ""; } result += static_cast(hexValue); @@ -728,7 +740,15 @@ std::string MetaFileMgr::RecordIdToCloudId(const std::string hexStr) return result; } -std::string MetaFileMgr::CloudIdToRecordId(const std::string cloudId) +/** + * @brief convert cloudId to recordId + * + * @param cloudId + * @param isHdc is homedatacenter's cloudId + * @return string recordId + * @example recordId: 012345678ff -> 12345678 when isHdc=true + */ +std::string MetaFileMgr::CloudIdToRecordId(const std::string cloudId, bool isHdc) { std::stringstream result; constexpr int width = 2; @@ -736,7 +756,18 @@ std::string MetaFileMgr::CloudIdToRecordId(const std::string cloudId) uint8_t u8Byte = cloudId[i]; result << std::setw(width) << std::setfill('0') << std::hex << static_cast(u8Byte); } - return result.str(); + if (!isHdc) { + return result.str(); + } + std::string recordId = result.str(); + if (recordId.at(0) == HDC_ID_START) { + recordId = recordId.substr(1); + } + auto pos = recordId.find(HDC_ID_END); + if (pos == std::string::npos) { + return recordId; + } + return recordId.substr(0, pos); } } // namespace FileManagement diff --git a/utils/system/include/dfsu_access_token_helper.h b/utils/system/include/dfsu_access_token_helper.h index b0f4c28f01109ae2350a91dc3e25d4ae9e75d6af..3d7398930178a0ee13ac1f6bfbca8a08b7cdfc23 100644 --- a/utils/system/include/dfsu_access_token_helper.h +++ b/utils/system/include/dfsu_access_token_helper.h @@ -35,6 +35,8 @@ public: static bool IsSystemApp(); static int32_t GetUserId(); static int32_t GetPid(); + static int32_t GetAccountId(int32_t &userId); + static bool IsUserVerifyed(const int32_t userId); }; } // namespace OHOS::FileManagement diff --git a/utils/system/src/dfsu_access_token_helper.cpp b/utils/system/src/dfsu_access_token_helper.cpp index c1bbbaea8d7296334c3cd9a0e46cfc310c56481f..a8209de3aad5355b50e984d99ccf8d7121a8f526 100644 --- a/utils/system/src/dfsu_access_token_helper.cpp +++ b/utils/system/src/dfsu_access_token_helper.cpp @@ -23,6 +23,7 @@ #include "uri.h" #include "utils_log.h" #include "want.h" +#include "os_account_manager.h" namespace OHOS::FileManagement { using namespace std; @@ -122,6 +123,32 @@ int32_t DfsuAccessTokenHelper::GetUserId() return uid / BASE_USER_RANGE; } +bool DfsuAccessTokenHelper::IsUserVerifyed(const int32_t userId) +{ + bool isVerified = false; + if (AccountSA::OsAccountManager::IsOsAccountVerified(userId, isVerified) != E_OK) { + LOGE("check user verified failed"); + return false; + } + return isVerified; +} + +int32_t DfsuAccessTokenHelper::GetAccountId(int32_t &userId) +{ + vector activeUsers; + if (AccountSA::OsAccountManager::QueryActiveOsAccountIds(activeUsers) != E_OK || activeUsers.empty()) { + LOGE("query active user failed"); + return E_OSACCOUNT; + } + userId = activeUsers.front(); + if (!IsUserVerifyed(userId)) { + LOGE("userId is invalid"); + return E_INVAL_ARG; + } + LOGI("GetAccountId ok, UserId: %{public}d", userId); + return E_OK; +} + int32_t DfsuAccessTokenHelper::GetPid() { auto pid = IPCSkeleton::GetCallingPid();