diff --git a/services/ans/src/common/notification_analytics_util.cpp b/services/ans/src/common/notification_analytics_util.cpp index 160a5cb002366357ec18aaba53c67ff6c7a6a57d..7bfa31ccefe927759996d78f87752a180a827a4a 100644 --- a/services/ans/src/common/notification_analytics_util.cpp +++ b/services/ans/src/common/notification_analytics_util.cpp @@ -637,7 +637,8 @@ std::string NotificationAnalyticsUtil::GetDeviceStatus(const sptr deviceStatus = request->GetdeviceStatus(); nlohmann::json deviceStatusJson; - for (map::const_iterator iter = deviceStatus.begin(); iter != deviceStatus.end(); ++iter) { + for (std::map::const_iterator iter = deviceStatus.begin(); + iter != deviceStatus.end(); ++iter) { deviceStatusJson[iter->first] = iter->second; } return deviceStatusJson.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace); @@ -949,7 +950,7 @@ std::string NotificationAnalyticsUtil::BuildExtraInfoWithReq(const HaMetaMessage extraInfo->SetParam("reason", AAFwk::String::Box(reason.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace))); } - + AAFwk::WantParamWrapper wWrapper(*extraInfo); return wWrapper.ToString(); @@ -1123,7 +1124,7 @@ void NotificationAnalyticsUtil::AggregateBadgeChange() EventFwk::Want want; nlohmann::json ansData; std::string badgeMessage; - std::vector removeBundles; + std::vector removeBundles; want.SetAction(NOTIFICATION_EVENT_PUSH_AGENT); ansData["subCode"] = std::to_string(BADGE_CHANGE_CODE); { @@ -1162,7 +1163,7 @@ void NotificationAnalyticsUtil::AggregateBadgeChange() badgeInfos.erase(bundle); } } - + if (!g_successReportFlag) { ExecuteSuccessCacheList(); } @@ -1484,7 +1485,7 @@ void NotificationAnalyticsUtil::ExecuteSlotReportList() g_reportSlotFlag = false; return; } - + sptr timer = MiscServices::TimeServiceClient::GetInstance(); if (timer == nullptr) { ANS_LOGE("Failed to start timer due to get TimeServiceClient is null."); diff --git a/services/ans/src/notification_extension/distributed_device_data_service.cpp b/services/ans/src/notification_extension/distributed_device_data_service.cpp index d68776ebc7e41dfe5fde5df433b39f817923abb9..f032744a91a15bca7f1c5dd9054bea30ad18d2ce 100644 --- a/services/ans/src/notification_extension/distributed_device_data_service.cpp +++ b/services/ans/src/notification_extension/distributed_device_data_service.cpp @@ -129,7 +129,7 @@ bool DistributedDeviceDataService::CheckDeviceBundleExist(const std::string& dev } } ANS_LOGW("Get bundle failed %{public}s %{public}s", deviceType.c_str(), StringAnonymous(deviceId).c_str()); - return true; + return false; } bool DistributedDeviceDataService::GetDeviceNotificationEnable(const std::string& deviceType, diff --git a/services/ans/test/unittest/BUILD.gn b/services/ans/test/unittest/BUILD.gn index 5ca5308fe2a879df129e0c78ed1a5bacc10c1d51..23ed4aee26159a1f1ed477e3e6aef84f9e51d22d 100644 --- a/services/ans/test/unittest/BUILD.gn +++ b/services/ans/test/unittest/BUILD.gn @@ -1467,25 +1467,120 @@ ohos_unittest("notification_extension_test") { "notification_extension/distributed_device_data_service_test.cpp", "notification_extension/distributed_extension_service_test.cpp", "notification_extension/mock_distributed_operation_callback.cpp", + "notification_extension/notification_config_parse_mock.cpp", + "notification_extension/notification_load_utils_mock.cpp", "notification_extension/notification_operation_service_test.cpp", - "notification_extension/softbus_socket_mock.cpp", + "${services_path}/ans/src/access_token_helper.cpp", + "${services_path}/ans/src/advanced_aggregation_data_roaming_observer.cpp", + "${services_path}/ans/src/advanced_datashare_helper.cpp", + "${services_path}/ans/src/advanced_datashare_helper_ext.cpp", + "${services_path}/ans/src/advanced_datashare_observer.cpp", + "${services_path}/ans/src/advanced_notification_manager/advanced_notification_cancel.cpp", + "${services_path}/ans/src/advanced_notification_clone_service.cpp", + "${services_path}/ans/src/advanced_notification_event_service.cpp", + "${services_path}/ans/src/advanced_notification_flow_control_service.cpp", + "${services_path}/ans/src/advanced_notification_inline.cpp", + "${services_path}/ans/src/advanced_notification_live_view_service.cpp", + "${services_path}/ans/src/advanced_notification_manager/advanced_notification_publish.cpp", + "${services_path}/ans/src/advanced_notification_manager/advanced_notification_query.cpp", + "${services_path}/ans/src/advanced_notification_publish/base_publish_process.cpp", + "${services_path}/ans/src/advanced_notification_publish/common_notification_publish_process.cpp", + "${services_path}/ans/src/advanced_notification_publish/live_publish_process.cpp", + "${services_path}/ans/src/advanced_notification_publish_service.cpp", + "${services_path}/ans/src/advanced_notification_reminder_service.cpp", + "${services_path}/ans/src/advanced_notification_service.cpp", + "${services_path}/ans/src/advanced_notification_service_ability.cpp", + "${services_path}/ans/src/advanced_notification_slot_service.cpp", + "${services_path}/ans/src/advanced_notification_subscriber_service.cpp", + "${services_path}/ans/src/advanced_notification_utils.cpp", + "${services_path}/ans/src/badge_manager/badge_manager.cpp", + "${services_path}/ans/src/bundle_manager_helper.cpp", + "${services_path}/ans/src/clone/dh_notification_clone_bundle_service.cpp", + "${services_path}/ans/src/clone/notification_clone_bundle_info.cpp", + "${services_path}/ans/src/clone/notification_clone_bundle_service.cpp", + "${services_path}/ans/src/clone/notification_clone_disturb_service.cpp", + "${services_path}/ans/src/clone/notification_clone_manager.cpp", + "${services_path}/ans/src/clone/notification_clone_util.cpp", + "${services_path}/ans/src/common/aes_gcm_helper.cpp", + "${services_path}/ans/src/common/file_utils.cpp", + "${services_path}/ans/src/common/notification_analytics_util.cpp", + "${services_path}/ans/src/common/ans_status.cpp", + "${services_path}/ans/src/common/notification_app_privileges.cpp", + "${services_path}/ans/src/distributed_device_status.cpp", + "${services_path}/ans/src/distributed_manager/advanced_notification_distributed_manager_service.cpp", + "${services_path}/ans/src/disturb_manager/advanced_notification_disturb_manager_service.cpp", + "${services_path}/ans/src/enable_manager/enable_manager.cpp", + "${services_path}/ans/src/event_report.cpp", + "${services_path}/ans/src/liveview_all_scenarios_extension_wrapper.cpp", + "${services_path}/ans/src/notification_dialog.cpp", + "${services_path}/ans/src/notification_dialog_manager.cpp", + "${services_path}/ans/src/notification_extension/distributed_device_data_service.cpp", + "${services_path}/ans/src/notification_extension/distributed_device_manager.cpp", + "${services_path}/ans/src/notification_extension/distributed_extension_service.cpp", + "${services_path}/ans/src/notification_extension/notification_operation_service.cpp", + "${services_path}/ans/src/notification_extension_wrapper.cpp", + "${services_path}/ans/src/notification_local_live_view_subscriber_manager.cpp", + "${services_path}/ans/src/notification_preferences.cpp", + "${services_path}/ans/src/notification_preferences_database.cpp", + "${services_path}/ans/src/notification_preferences_info.cpp", + "${services_path}/ans/src/notification_rdb_data_mgr.cpp", + "${services_path}/ans/src/notification_slot_filter.cpp", + "${services_path}/ans/src/notification_smart_reminder/reminder_affected.cpp", + "${services_path}/ans/src/notification_smart_reminder/smart_reminder_center.cpp", + "${services_path}/ans/src/notification_smart_reminder/string_utils.cpp", + "${services_path}/ans/src/notification_subscriber_manager.cpp", + "${services_path}/ans/src/notification_timer_info.cpp", + "${services_path}/ans/src/os_account_manager_helper.cpp", + "${services_path}/ans/src/permission_filter.cpp", + "${services_path}/ans/src/reminder_swing_decision_center.cpp", + "${services_path}/ans/src/report_time_info.cpp", + "${services_path}/ans/src/system_dialog_connect_stb.cpp", + "${services_path}/ans/src/system_event_observer.cpp", + "${services_path}/ans/src/system_live_view/advanced_notification_system_live_view_service.cpp", + "${services_path}/ans/src/telephony_extension_wrapper.cpp", ] defines = [] deps = [ "${frameworks_module_ans_path}:ans_innerkits", - "${services_path}/ans:libans", + "${frameworks_module_reminder_path}:reminder_innerkits", ] external_deps = [ - "ability_base:zuri", + "ability_base:configuration", + "ability_runtime:ability_manager", + "ability_runtime:app_manager", + "ability_runtime:appkit_native", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "config_policy:configpolicy_util", + "data_share:datashare_common", + "data_share:datashare_consumer", + "data_share:datashare_permission", "device_manager:devicemanagersdk", - "dsoftbus:softbus_client", "ffrt:libffrt", "hilog:libhilog", + "hitrace:hitrace_meter", + "hitrace:libhitracechain", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", "ipc:ipc_single", + "kv_store:distributeddata_inner", + "openssl:libcrypto_shared", + "os_account:os_account_innerkits", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", "time_service:time_client", ] diff --git a/services/ans/test/unittest/mock/include/mock_device_manager_impl.h b/services/ans/test/unittest/mock/include/mock_device_manager_impl.h index 616c3529101f4ff67b2141c9f6ad8bc1e2b9bbed..bbd50f8296ff8ca479bf8277858a060948221952 100644 --- a/services/ans/test/unittest/mock/include/mock_device_manager_impl.h +++ b/services/ans/test/unittest/mock/include/mock_device_manager_impl.h @@ -23,6 +23,11 @@ namespace Notification { class DeviceTrigger { public: + static void MockConfigScene(int32_t scene); + static void MockInitDeviceManager(bool mock); + static void MockGetTrustedDeviceList(bool mock); + static void MockRegisterDevStateCallback(bool mock); + static void TriggerOnRemoteDied(); static void TriggerDeviceOnline(); static void TriggerDeviceOffline(); static void TriggerDeviceChanged(); diff --git a/services/ans/test/unittest/notification_extension/device_manager_impl_mock.cpp b/services/ans/test/unittest/notification_extension/device_manager_impl_mock.cpp index 4ae044a7274471e565f6275aef74b167b5ec9bda..cf4672e00f21c4e75e3cfc003a5d37828057f53e 100644 --- a/services/ans/test/unittest/notification_extension/device_manager_impl_mock.cpp +++ b/services/ans/test/unittest/notification_extension/device_manager_impl_mock.cpp @@ -20,6 +20,30 @@ namespace OHOS { namespace Notification { static std::shared_ptr deviceManagerCallback = nullptr; +static std::shared_ptr dmInitCallback = nullptr; +static bool g_mockInitDeviceManager = false; +static bool g_mockGetTrustedDeviceList = false; +static bool g_mockRegisterDevStateCallback = false; + +void DeviceTrigger::MockInitDeviceManager(bool mock) +{ + g_mockInitDeviceManager = mock; +} + +void DeviceTrigger::MockGetTrustedDeviceList(bool mock) +{ + g_mockGetTrustedDeviceList = mock; +} + +void DeviceTrigger::MockRegisterDevStateCallback(bool mock) +{ + g_mockRegisterDevStateCallback = mock; +} + +void DeviceTrigger::TriggerOnRemoteDied() +{ + dmInitCallback->OnRemoteDied(); +} void DeviceTrigger::TriggerDeviceOnline() { @@ -64,15 +88,19 @@ DeviceManagerImpl &DeviceManagerImpl::GetInstance() return deviceManagerImpl; } -int32_t DeviceManagerImpl::InitDeviceManager(const std::string &pkgName, std::shared_ptr dmInitCallback) +int32_t DeviceManagerImpl::InitDeviceManager(const std::string &pkgName, std::shared_ptr callback) { - (void)dmInitCallback; + if (Notification::g_mockInitDeviceManager) { + return -1; + } + Notification::dmInitCallback = callback; printf("InitDeviceManager pkgName:%s\n", pkgName.c_str()); return 0; } int32_t DeviceManagerImpl::UnInitDeviceManager(const std::string &pkgName) { + Notification::dmInitCallback = nullptr; printf("UnInitDeviceManager pkgName:%s\n", pkgName.c_str()); return 0; } @@ -80,6 +108,9 @@ int32_t DeviceManagerImpl::UnInitDeviceManager(const std::string &pkgName) int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, std::vector &deviceList) { + if (Notification::g_mockGetTrustedDeviceList) { + return -1; + } DmDeviceInfo remoteDevice; memset_s(&remoteDevice, sizeof(remoteDevice), 0, sizeof(remoteDevice)); strcpy_s(remoteDevice.deviceId, sizeof(remoteDevice.deviceId) - 1, "remoteDeviceId"); @@ -92,6 +123,9 @@ int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, cons int32_t DeviceManagerImpl::GetTrustedDeviceList( const std::string &pkgName, const std::string &extra, bool isRefresh, std::vector &deviceList) { + if (Notification::g_mockGetTrustedDeviceList) { + return -1; + } DmDeviceInfo remoteDevice; memset_s(&remoteDevice, sizeof(remoteDevice), 0, sizeof(remoteDevice)); strcpy_s(remoteDevice.deviceId, sizeof(remoteDevice.deviceId) - 1, "remoteDeviceId"); @@ -113,6 +147,9 @@ int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDevi int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName, const std::string &extra, std::shared_ptr callback) { + if (Notification::g_mockRegisterDevStateCallback) { + return -1; + } Notification::deviceManagerCallback = callback; return 0; } diff --git a/services/ans/test/unittest/notification_extension/distributed_device_data_service_test.cpp b/services/ans/test/unittest/notification_extension/distributed_device_data_service_test.cpp index 900646a9e0119c51d94785ed7455c17a8564ba8f..d5b7b87a95059289b24e15eac945721fe71bb5fe 100644 --- a/services/ans/test/unittest/notification_extension/distributed_device_data_service_test.cpp +++ b/services/ans/test/unittest/notification_extension/distributed_device_data_service_test.cpp @@ -61,6 +61,8 @@ HWTEST_F(DistributedDeviceDataServiceTest, DeviceData_00001, Function | SmallTes // add device sync switch data failed, because deviceType or deviceId is empty. int32_t result = DistributedDeviceDataService::GetInstance().SetDeviceSyncSwitch("", "", true, true); ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); + result = DistributedDeviceDataService::GetInstance().SetDeviceSyncSwitch(DEVICE_TYPE, "", true, true); + ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); // add device sync switch data result = DistributedDeviceDataService::GetInstance().SetDeviceSyncSwitch(DEVICE_TYPE, @@ -68,17 +70,35 @@ HWTEST_F(DistributedDeviceDataServiceTest, DeviceData_00001, Function | SmallTes ASSERT_EQ(result, (int)ERR_OK); bool liveView = DistributedDeviceDataService::GetInstance().GetDeviceLiveViewEnable(DEVICE_TYPE, DEVICE_ID); - ASSERT_EQ(true, liveView); + ASSERT_EQ(liveView, true); + + liveView = DistributedDeviceDataService::GetInstance().GetDeviceLiveViewEnable("", DEVICE_ID); + ASSERT_EQ(liveView, false); + liveView = DistributedDeviceDataService::GetInstance().GetDeviceLiveViewEnable(DEVICE_TYPE, ""); + ASSERT_EQ(liveView, false); bool notification = DistributedDeviceDataService::GetInstance().GetDeviceNotificationEnable(DEVICE_TYPE, DEVICE_ID); ASSERT_EQ(true, notification); + notification = DistributedDeviceDataService::GetInstance().GetDeviceNotificationEnable("", DEVICE_ID); + ASSERT_EQ(false, notification); + notification = DistributedDeviceDataService::GetInstance().GetDeviceNotificationEnable(DEVICE_TYPE, ""); + ASSERT_EQ(false, notification); + // change device sync switch data result = DistributedDeviceDataService::GetInstance().SetDeviceSyncSwitch(DEVICE_TYPE, DEVICE_ID, true, false); notification = DistributedDeviceDataService::GetInstance().GetDeviceLiveViewEnable(DEVICE_TYPE, DEVICE_ID); ASSERT_EQ(false, notification); + result = DistributedDeviceDataService::GetInstance().SetDeviceSyncSwitch("", DEVICE_ID, true, true); + ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); + result = DistributedDeviceDataService::GetInstance().SetDeviceSyncSwitch(DEVICE_TYPE, "", true, true); + ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); + // clear data + DistributedDeviceDataService::GetInstance().ResetTargetDevice("", DEVICE_ID); + DistributedDeviceDataService::GetInstance().ResetTargetDevice(DEVICE_TYPE, ""); + DistributedDeviceDataService::GetInstance().ResetTargetDevice(DEVICE_TYPE, DEVICE_ID); } /** @@ -89,21 +109,46 @@ HWTEST_F(DistributedDeviceDataServiceTest, DeviceData_00001, Function | SmallTes */ HWTEST_F(DistributedDeviceDataServiceTest, DeviceData_00002, Function | SmallTest | Level1) { + // clear data + DistributedDeviceDataService::GetInstance().ResetTargetDevice(DEVICE_TYPE, DEVICE_ID); StringAnonymous(DEVICE_ID); // add device installed bundles failed, because deviceType or deviceId is empty. int32_t result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList("", DEVICE_ID, BunleListOperationType::ADD_BUNDLES, {}); ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); + result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList(DEVICE_TYPE, + "", BunleListOperationType::ADD_BUNDLES, {}); + ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); + result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList(DEVICE_TYPE, + DEVICE_ID, BunleListOperationType::REMOVE_BUNDLES, {}); + ASSERT_EQ(result, (int)ERR_ANS_INVALID_PARAM); // add device installed bundles std::vector bundleList = { "ohos.com.test1", "ohos.com.test2" }; result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList(DEVICE_TYPE, DEVICE_ID, BunleListOperationType::ADD_BUNDLES, bundleList); ASSERT_EQ(result, (int)ERR_OK); + result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList(DEVICE_TYPE, + DEVICE_ID, BunleListOperationType::ADD_BUNDLES, { "ohos.com.test0" }); + ASSERT_EQ(result, (int)ERR_OK); + result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList("Pad", + DEVICE_ID, BunleListOperationType::ADD_BUNDLES, { "ohos.com.test0" }); + ASSERT_EQ(result, (int)ERR_OK); + result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList(DEVICE_TYPE, + "abcdef", BunleListOperationType::ADD_BUNDLES, { "ohos.com.test0" }); + ASSERT_EQ(result, (int)ERR_OK); bool exist = DistributedDeviceDataService::GetInstance().CheckDeviceBundleExist(DEVICE_TYPE, DEVICE_ID, "ohos.com.test1"); ASSERT_EQ(exist, true); + exist = DistributedDeviceDataService::GetInstance().CheckDeviceBundleExist("", + DEVICE_ID, "ohos.com.test1"); + ASSERT_EQ(exist, false); + + exist = DistributedDeviceDataService::GetInstance().CheckDeviceBundleExist(DEVICE_TYPE, + "", "ohos.com.test1"); + ASSERT_EQ(exist, false); + // remove device installed bundles result = DistributedDeviceDataService::GetInstance().SetTargetDeviceBundleList(DEVICE_TYPE, DEVICE_ID, BunleListOperationType::REMOVE_BUNDLES, { "ohos.com.test1" }); diff --git a/services/ans/test/unittest/notification_extension/distributed_extension_service_test.cpp b/services/ans/test/unittest/notification_extension/distributed_extension_service_test.cpp index 8ad198c20abcd6b074cda1b7c6f50ce033d72cfa..da3187dc9d8dd75213dbf6e31e7313814f2a4b03 100644 --- a/services/ans/test/unittest/notification_extension/distributed_extension_service_test.cpp +++ b/services/ans/test/unittest/notification_extension/distributed_extension_service_test.cpp @@ -60,9 +60,7 @@ HWTEST_F(DistributedExtensionServiceTest, extension_00001, Function | SmallTest ASSERT_EQ(result, true); DistributedDeviceConfig config = DistributedExtensionService::GetInstance().deviceConfig_; if (config.localType == "Phone") { - ASSERT_EQ(config.supportPeerDevice.count("Pc"), 1); ASSERT_EQ(config.supportPeerDevice.count("Watch"), 1); - ASSERT_EQ(config.supportPeerDevice.count("Tablet"), 1); } } @@ -72,7 +70,7 @@ HWTEST_F(DistributedExtensionServiceTest, extension_00001, Function | SmallTest * @tc.type: FUNC * @tc.require: issue */ -HWTEST_F(DistributedExtensionServiceTest, extension_00003, Function | SmallTest | Level1) +HWTEST_F(DistributedExtensionServiceTest, extension_00002, Function | SmallTest | Level1) { std::string deviceType; deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_WATCH); @@ -85,12 +83,54 @@ HWTEST_F(DistributedExtensionServiceTest, extension_00003, Function | SmallTest ASSERT_EQ(deviceType, "Pc"); deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_PC); ASSERT_EQ(deviceType, "Pc"); + deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_WIFI_CAMERA); + ASSERT_EQ(deviceType, ""); deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_PAD); ASSERT_EQ(deviceType, "pad"); deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_PC); ASSERT_EQ(deviceType, "pc"); deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_2IN1); ASSERT_EQ(deviceType, "pc"); + deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_WATCH); + ASSERT_EQ(deviceType, ""); +} + +/** + * @tc.name: Distributed extension service + * @tc.desc: Check device Type Convert + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedExtensionServiceTest, extension_00003, Function | SmallTest | Level1) +{ + nlohmann::json operationJson; + operationJson["operationReplyTimeout"] = 10; + DistributedExtensionService::GetInstance().SetOperationReplyTimeout(operationJson); + int32_t data = DistributedExtensionService::GetInstance().deviceConfig_.operationReplyTimeout; + ASSERT_EQ(data, 10); + nlohmann::json emptyTimeJson; + DistributedExtensionService::GetInstance().SetOperationReplyTimeout(emptyTimeJson); + data = DistributedExtensionService::GetInstance().deviceConfig_.operationReplyTimeout; + ASSERT_EQ(data, 3); + emptyTimeJson["operationReplyTimeout"] = "10"; + DistributedExtensionService::GetInstance().SetOperationReplyTimeout(emptyTimeJson); + data = DistributedExtensionService::GetInstance().deviceConfig_.operationReplyTimeout; + ASSERT_EQ(data, 3); + + + nlohmann::json contentJson; + contentJson["maxContentLength"] = 20; + DistributedExtensionService::GetInstance().SetMaxContentLength(contentJson); + data = DistributedExtensionService::GetInstance().deviceConfig_.maxContentLength; + ASSERT_EQ(data, 20); + nlohmann::json emptyJson; + DistributedExtensionService::GetInstance().SetMaxContentLength(emptyJson); + data = DistributedExtensionService::GetInstance().deviceConfig_.maxContentLength; + ASSERT_EQ(data, 400); + emptyJson["maxContentLength"] = "20"; + DistributedExtensionService::GetInstance().SetMaxContentLength(emptyJson); + data = DistributedExtensionService::GetInstance().deviceConfig_.maxContentLength; + ASSERT_EQ(data, 400); } /** @@ -99,32 +139,108 @@ HWTEST_F(DistributedExtensionServiceTest, extension_00003, Function | SmallTest * @tc.type: FUNC * @tc.require: issue */ -HWTEST_F(DistributedExtensionServiceTest, extension_00002, Function | SmallTest | Level1) +HWTEST_F(DistributedExtensionServiceTest, extension_00004, Function | SmallTest | Level1) { // register device manager. bool result = DistributedDeviceManager::GetInstance().RegisterDms(true); ASSERT_EQ(result, true); // register device manager. + DeviceTrigger::TriggerOnRemoteDied(); + DistributedExtensionService::GetInstance().HADotCallback(0, 0, 0, "{\"deviceType\":\"pc\"}"); + DistributedExtensionService::GetInstance().HADotCallback(0, 0, 0, "{\"result\":\"ok\"}"); DistributedDeviceManager::GetInstance().InitTrustList(); // trigger device online DeviceTrigger::TriggerDeviceOnline(); DistributedExtensionService::GetInstance().OnAllConnectOnline(); sleep(1); // check online device + DistributedExtensionService::GetInstance().HADotCallback(7, 0, BRANCH_3, "{\"result\":\"ok\"}"); bool isEmpty = DistributedExtensionService::GetInstance().deviceMap_.empty(); ASSERT_EQ(isEmpty, false); // trigger device ready + DistributedExtensionService::GetInstance().HADotCallback(7, 0, BRANCH_4, "{\"result\":\"ok\"}"); DeviceTrigger::TriggerDeviceReady(); // trigger device change + DistributedExtensionService::GetInstance().HADotCallback(7, 5, BRANCH_5, "{\"result\":\"ok\"}"); DeviceTrigger::TriggerDeviceChanged(); // trigger device offline + DistributedExtensionService::GetInstance().HADotCallback(5, 0, BRANCH_5, "{\"result\":\"ok\"}"); DeviceTrigger::TriggerDeviceOffline(); sleep(1); + DistributedExtensionService::GetInstance().HADotCallback(6, 0, 0, "{\"result\":\"ok\"}"); + DistributedExtensionService::GetInstance().SendReportCallback(7, 0, "ok"); // check online device isEmpty = DistributedExtensionService::GetInstance().deviceMap_.empty(); ASSERT_EQ(isEmpty, true); - sleep(1); - DistributedExtensionService::GetInstance().distributedQueue_ = nullptr; +} + +/** + * @tc.name: Distributed extension service + * @tc.desc: Check branch when ffrt is null + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedExtensionServiceTest, extension_00005, Function | SmallTest | Level1) +{ + // register device manager. + DeviceTrigger::MockInitDeviceManager(true); + bool result = DistributedDeviceManager::GetInstance().RegisterDms(true); + ASSERT_EQ(result, false); + DeviceTrigger::MockInitDeviceManager(false); + + DeviceTrigger::MockRegisterDevStateCallback(true); + DistributedDeviceManager::GetInstance().hasInit.store(false); + DistributedDeviceManager::GetInstance().InitTrustList(); + result = DistributedDeviceManager::GetInstance().RegisterDms(true); + ASSERT_EQ(result, false); + DistributedDeviceManager::GetInstance().hasInit.store(true); + DeviceTrigger::MockGetTrustedDeviceList(true); + DistributedDeviceManager::GetInstance().InitTrustList(); + DeviceTrigger::MockGetTrustedDeviceList(false); + DeviceTrigger::MockRegisterDevStateCallback(false); + result = DistributedDeviceManager::GetInstance().RegisterDms(true); + ASSERT_EQ(result, true); +} + +/** + * @tc.name: Distributed extension service + * @tc.desc: Check ccm config + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedExtensionServiceTest, extension_00006, Function | SmallTest | Level1) +{ + DistributedDeviceConfig config; + DistributedExtensionService::GetInstance().deviceConfig_ = config; + // register device manager. + DeviceTrigger::MockConfigScene(0); + bool result = DistributedExtensionService::GetInstance().initConfig(); + ASSERT_EQ(result, false); + + DeviceTrigger::MockConfigScene(1); + result = DistributedExtensionService::GetInstance().initConfig(); + ASSERT_EQ(result, false); + + DeviceTrigger::MockConfigScene(2); + result = DistributedExtensionService::GetInstance().initConfig(); + ASSERT_EQ(result, false); + + DeviceTrigger::MockConfigScene(3); + result = DistributedExtensionService::GetInstance().initConfig(); + ASSERT_EQ(result, false); + + DeviceTrigger::MockConfigScene(4); + result = DistributedExtensionService::GetInstance().initConfig(); + ASSERT_EQ(result, true); + std::string localType = DistributedExtensionService::GetInstance().deviceConfig_.localType; + ASSERT_EQ(localType.empty(), true); + auto peers = DistributedExtensionService::GetInstance().deviceConfig_.supportPeerDevice; + ASSERT_EQ(peers.empty(), false); + int len = DistributedExtensionService::GetInstance().deviceConfig_.maxTitleLength; + ASSERT_EQ(len, 200); + DeviceTrigger::MockConfigScene(-1); + result = DistributedExtensionService::GetInstance().initConfig(); + ASSERT_EQ(result, true); } } } diff --git a/services/ans/test/unittest/notification_extension/notification_config_parse_mock.cpp b/services/ans/test/unittest/notification_extension/notification_config_parse_mock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..12ce89cb1b36b72c259a235bce1069f47994a842 --- /dev/null +++ b/services/ans/test/unittest/notification_extension/notification_config_parse_mock.cpp @@ -0,0 +1,189 @@ +/* +* Copyright (c) 2021-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 "notification_config_parse.h" + +#include "ans_log_wrapper.h" +#ifdef ENABLE_ANS_ADDITIONAL_CONTROL +#include "notification_extension_wrapper.h" +#endif +#include "notification_slot.h" +#include "file_utils.h" +#include "mock_device_manager_impl.h" + +namespace OHOS { +namespace Notification { +static int32_t g_configScene = -1; +constexpr int32_t CONFIG_SCENE_0 = 0; +constexpr int32_t CONFIG_SCENE_1 = 1; +constexpr int32_t CONFIG_SCENE_2 = 2; +constexpr int32_t CONFIG_SCENE_3 = 3; +constexpr int32_t CONFIG_SCENE_4 = 4; +constexpr int32_t DEFAULT_TITLE_LENGTH = 200; +constexpr int32_t DEFAULT_CONTENT_LENGTH = 400; +constexpr int32_t MOCK_DEFAULT_REPLY_TIMEOUT = 3; + +void DeviceTrigger::MockConfigScene(int32_t scene) +{ + g_configScene = scene; +} + +NotificationConfigParse::NotificationConfigParse() +{ +} + +std::shared_ptr NotificationConfigParse::GetAppPrivileges( + const std::string &bundleName) const +{ + return nullptr; +} + +bool NotificationConfigParse::GetConfigJson(const std::string &keyCheck, nlohmann::json &configJson) const +{ + if (g_configScene == CONFIG_SCENE_0) { + return false; + } + if (g_configScene == CONFIG_SCENE_1) { + return true; + } + if (g_configScene == CONFIG_SCENE_2) { + nlohmann::json distribuedConfig; + nlohmann::json notificationService; + notificationService["distribuedConfig"] = distribuedConfig; + configJson["notificationService"] = notificationService; + return true; + } + if (g_configScene == CONFIG_SCENE_3) { + nlohmann::json distribuedConfig; + distribuedConfig["maxContentLength"] = std::string(); + nlohmann::json notificationService; + notificationService["distribuedConfig"] = distribuedConfig; + configJson["notificationService"] = notificationService; + return true; + } + if (g_configScene == CONFIG_SCENE_4) { + nlohmann::json distribuedConfig; + nlohmann::json supportPeerDevice = nlohmann::json::array(); + supportPeerDevice.emplace_back("Watch"); + distribuedConfig["supportPeerDevice"] = supportPeerDevice; + nlohmann::json notificationService; + notificationService["distribuedConfig"] = distribuedConfig; + configJson["notificationService"] = notificationService; + return true; + } + nlohmann::json distribuedConfig; + nlohmann::json supportPeerDevice = nlohmann::json::array(); + supportPeerDevice.emplace_back("Watch"); + distribuedConfig["localType"] = "Phone"; + distribuedConfig["supportPeerDevice"] = supportPeerDevice; + distribuedConfig["maxTitleLength"] = DEFAULT_TITLE_LENGTH; + distribuedConfig["maxContentLength"] = DEFAULT_CONTENT_LENGTH; + nlohmann::json notificationService; + notificationService["distribuedConfig"] = distribuedConfig; + configJson["notificationService"] = notificationService; + return true; +} + +bool NotificationConfigParse::GetCurrentSlotReminder( + std::map> ¤tSlotReminder) const +{ + return true; +} + +uint32_t NotificationConfigParse::GetConfigSlotReminderModeByType(NotificationConstant::SlotType slotType) +{ + return 0; +} + +bool NotificationConfigParse::IsLiveViewEnabled(const std::string bundleName) const +{ + return true; +} + +bool NotificationConfigParse::IsReminderEnabled(const std::string& bundleName) const +{ + return true; +} + +bool NotificationConfigParse::IsDistributedReplyEnabled(const std::string& bundleName) const +{ + return true; +} + +bool NotificationConfigParse::IsBannerEnabled(const std::string bundleName) const +{ + return false; +} + +void NotificationConfigParse::GetFlowCtrlConfigFromCCM(FlowControlThreshold &threshold) +{ +} + +bool NotificationConfigParse::GetSmartReminderEnableList(std::vector& deviceTypes) +{ + return true; +} + +bool NotificationConfigParse::GetMirrorNotificationEnabledStatus(std::vector& deviceTypes) +{ + return true; +} + +bool NotificationConfigParse::GetAppAndDeviceRelationMap(std::map& relationMap) +{ + return true; +} + +std::unordered_set NotificationConfigParse::GetCollaborativeDeleteType() const +{ + std::unordered_set collaborativeDeleteTypeSet; + collaborativeDeleteTypeSet.insert("LIVE_VIEW"); + collaborativeDeleteTypeSet.insert("SOCIAL_COMMUNICATION"); + return collaborativeDeleteTypeSet; +} + +bool NotificationConfigParse::GetFilterUidAndBundleName(const std::string &key) +{ + return false; +} + +void NotificationConfigParse::GetCollaborationFilter() +{ +} + +bool NotificationConfigParse::IsInCollaborationFilter(const std::string& bundleName, int32_t uid) const +{ + return false; +} + +uint32_t NotificationConfigParse::GetStartAbilityTimeout() +{ + return MOCK_DEFAULT_REPLY_TIMEOUT; +} + +void NotificationConfigParse::GetReportTrustListConfig() +{ + return; +} + +bool NotificationConfigParse::IsReportTrustList(const std::string& bundleName) const +{ + return true; +} +} // namespace Notification +} // namespace OHOS + diff --git a/services/ans/test/unittest/notification_extension/notification_load_utils_mock.cpp b/services/ans/test/unittest/notification_extension/notification_load_utils_mock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..915002544d8b7ea524810cf066c6a7de5d7b0379 --- /dev/null +++ b/services/ans/test/unittest/notification_extension/notification_load_utils_mock.cpp @@ -0,0 +1,148 @@ +/* + * 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 "notifictaion_load_utils.h" + +#include +#include +#include "distributed_data_define.h" +#include "ans_log_wrapper.h" +#include "mock_device_manager_impl.h" + +namespace OHOS { +namespace Notification { + +static bool g_notificationProxyValid = false; +static std::map g_deviceList; + +void DeviceCheck::ResetDeviceData() +{ + return g_deviceList.clear(); +} + +bool DeviceCheck::CheckDeviceOnline() +{ + return !g_deviceList.empty(); +} + +std::string DeviceCheck::GetDeviceNetworkId(std::string deviceId) +{ + if (g_deviceList.find(deviceId) == g_deviceList.end()) { + return std::string(); + } + return g_deviceList[deviceId]; +} + +int32_t InitLocalDevice(const std::string &deviceId, uint16_t deviceType, + DistributedDeviceConfig config) +{ + return 0; +} + +void AddDevice(const std::string &deviceId, const std::string &udid, uint16_t deviceType, + const std::string &networkId) +{ + g_deviceList.insert({deviceId, networkId}); + return; +} + +void DeviceStatusChange(const DeviceStatueChangeInfo& changeInfo) +{ + return; +} + +void ReleaseDevice(const std::string &deviceId, uint16_t deviceType) +{ + g_deviceList.erase(deviceId); + return; +} + +void RefreshDevice(const std::string &deviceId, uint16_t deviceType, const std::string &networkId) +{ + if (g_deviceList.find(deviceId) == g_deviceList.end()) { + return; + } + g_deviceList[deviceId] = networkId; + return; +} + +void ReleaseLocalDevice() +{ + return; +} + +void InitHACallBack(std::function callback) +{ + return; +} + +void InitSendReportCallBack(std::function callback) +{ + return; +} + +NotificationLoadUtils::NotificationLoadUtils(const std::string& path) : path_(path) +{ + g_notificationProxyValid = true; + return; +} + +NotificationLoadUtils::~NotificationLoadUtils() +{ + g_notificationProxyValid = false; + if (proxyHandle_ == nullptr) { + return; + } + int result = dlclose(proxyHandle_); + ANS_LOGI("Release symbol %{public}d, name: %{public}s", result, path_.c_str()); + proxyHandle_ = nullptr; +} + +void* NotificationLoadUtils::GetProxyFunc(const std::string& func) +{ + if (func == "InitLocalDevice") { + return (void*)&InitLocalDevice; + } + if (func == "InitSendReportCallBack") { + return (void*)&InitSendReportCallBack; + } + if (func == "InitHACallBack") { + return (void*)&InitHACallBack; + } + if (func == "ReleaseLocalDevice") { + return (void*)&ReleaseLocalDevice; + } + if (func == "AddDevice") { + return (void*)&AddDevice; + } + if (func == "ReleaseDevice") { + return (void*)&ReleaseDevice; + } + if (func == "RefreshDevice") { + return (void*)&RefreshDevice; + } + if (func == "DeviceStatusChange") { + return (void*)&DeviceStatusChange; + } + return nullptr; +} + +bool NotificationLoadUtils::IsValid() +{ + return g_notificationProxyValid; +} + +} +} diff --git a/services/ans/test/unittest/notification_extension/notification_operation_service_test.cpp b/services/ans/test/unittest/notification_extension/notification_operation_service_test.cpp index 95e9ce65879b23c061a4cbd147e30727dc8ea5bb..1d5daee219261ccfd18362d0bd9113379295a253 100644 --- a/services/ans/test/unittest/notification_extension/notification_operation_service_test.cpp +++ b/services/ans/test/unittest/notification_extension/notification_operation_service_test.cpp @@ -75,8 +75,10 @@ HWTEST_F(DistributedOperationServiceTest, DeviceData_00002, Function | SmallTest { MockOperationCallback::ResetOperationResult(); // add operation. - sptr callback = new (std::nothrow) MockOperationCallback(); - DistributedOperationService::GetInstance().AddOperation("abcd", callback); + sptr callback1 = new (std::nothrow) MockOperationCallback(); + sptr callback2 = new (std::nothrow) MockOperationCallback(); + DistributedOperationService::GetInstance().AddOperation("abcd", callback1); + DistributedOperationService::GetInstance().AddOperation("abcd", callback2); // invoke time out operation. DistributedOperationService::GetInstance().HandleOperationTimeOut("abcd"); // time out operation result. @@ -103,5 +105,26 @@ HWTEST_F(DistributedOperationServiceTest, DeviceData_00003, Function | SmallTest int32_t result = MockOperationCallback::GetOperationResult(); ASSERT_EQ(result, 0); } + +/** + * @tc.name: Device sync switch check + * @tc.desc: Test device data service + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedOperationServiceTest, DeviceData_00004, Function | SmallTest | Level1) +{ + MockOperationCallback::ResetOperationResult(); + // add operation. + sptr callback = new (std::nothrow) MockOperationCallback(); + DistributedOperationService::GetInstance().AddOperation("abcd", callback); + DistributedOperationService::GetInstance().operationQueue_ = nullptr; + OperationTimerInfo TimerInfo = OperationTimerInfo("hashCode"); + TimerInfo.OnTrigger(); + // invoke successful operation. + sleep(4); + int32_t result = MockOperationCallback::GetOperationResult(); + ASSERT_EQ(result, -1); +} } } diff --git a/services/ans/test/unittest/notification_extension/softbus_socket_mock.cpp b/services/ans/test/unittest/notification_extension/softbus_socket_mock.cpp deleted file mode 100644 index 271a358bd3535cb76aef25698609254e649fbb5a..0000000000000000000000000000000000000000 --- a/services/ans/test/unittest/notification_extension/softbus_socket_mock.cpp +++ /dev/null @@ -1,77 +0,0 @@ -/* - * 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 "socket.h" - - -int32_t Socket(SocketInfo info) -{ - return 1; -} - -int32_t Listen(int32_t socket, const QosTV qos[], uint32_t qosCount, const ISocketListener *listener) -{ - return 0; -} - -int32_t Bind(int32_t socket, const QosTV qos[], uint32_t qosCount, const ISocketListener *listener) -{ - return 0; -} - -int32_t BindAsync(int32_t socket, const QosTV qos[], uint32_t qosCount, const ISocketListener *listener) -{ - return 0; -} - -int32_t SendBytes(int32_t socket, const void *data, uint32_t len) -{ - return 0; -} - -int32_t SendBytesAsync(int32_t socket, uint32_t dataSeq, const void *data, uint32_t len) -{ - return 0; -} - -int32_t SendMessage(int32_t socket, const void *data, uint32_t len) -{ - return 0; -} - -int32_t SendStream(int32_t socket, const StreamData *data, const StreamData *ext, - const StreamFrameInfo *param) -{ - return 0; -} - -int32_t SendFile(int32_t socket, const char *sFileList[], const char *dFileList[], uint32_t fileCnt) -{ - return 0; -} - -void Shutdown(int32_t socket) -{ -} - -int32_t EvaluateQos(const char *peerNetworkId, TransDataType dataType, const QosTV *qos, uint32_t qosCount) -{ - return 0; -} - -int32_t SetAccessInfo(int32_t socket, SocketAccessInfo accessInfo) -{ - return 0; -}